atlas-chat 0.1.0__py3-none-any.whl

atlas/tests/test_file_extraction_routes.py

@@ -0,0 +1,158 @@
+"""Tests for file extraction config exposure in /api/config endpoint."""
+
+from unittest.mock import patch
+
+from main import app
+from starlette.testclient import TestClient
+
+from atlas.infrastructure.app_factory import app_factory
+from atlas.modules.config.config_manager import FileExtractorConfig, FileExtractorsConfig
+
+
+def test_config_endpoint_includes_file_extraction_feature_flag():
+    """Config endpoint should include file_content_extraction in features."""
+    client = TestClient(app)
+    resp = client.get("/api/config", headers={"X-User-Email": "test@test.com"})
+
+    assert resp.status_code == 200
+    data = resp.json()
+    assert "features" in data
+    assert "file_content_extraction" in data["features"]
+    assert isinstance(data["features"]["file_content_extraction"], bool)
+
+
+def test_config_endpoint_includes_file_extraction_config():
+    """Config endpoint should include file_extraction configuration."""
+    client = TestClient(app)
+    resp = client.get("/api/config", headers={"X-User-Email": "test@test.com"})
+
+    assert resp.status_code == 200
+    data = resp.json()
+    assert "file_extraction" in data
+    file_extraction = data["file_extraction"]
+    assert "enabled" in file_extraction
+    assert "default_behavior" in file_extraction
+    assert "supported_extensions" in file_extraction
+
+
+def test_file_extraction_disabled_when_feature_flag_off():
+    """File extraction should be disabled when feature flag is off."""
+    config_manager = app_factory.get_config_manager()
+    original_setting = config_manager.app_settings.feature_file_content_extraction_enabled
+
+    try:
+        config_manager.app_settings.feature_file_content_extraction_enabled = False
+
+        client = TestClient(app)
+        resp = client.get("/api/config", headers={"X-User-Email": "test@test.com"})
+
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["features"]["file_content_extraction"] is False
+        assert data["file_extraction"]["enabled"] is False
+        assert data["file_extraction"]["default_behavior"] == "none"
+        assert data["file_extraction"]["supported_extensions"] == []
+    finally:
+        config_manager.app_settings.feature_file_content_extraction_enabled = original_setting
+
+
+def test_file_extraction_enabled_with_correct_extensions():
+    """File extraction should show supported extensions when enabled."""
+    config_manager = app_factory.get_config_manager()
+    original_feature = config_manager.app_settings.feature_file_content_extraction_enabled
+    original_extractors = config_manager._file_extractors_config
+
+    try:
+        # Enable feature and set up test config
+        config_manager.app_settings.feature_file_content_extraction_enabled = True
+        config_manager._file_extractors_config = FileExtractorsConfig(
+            enabled=True,
+            default_behavior="extract",
+            extractors={
+                "pdf-text": FileExtractorConfig(url="http://localhost/pdf", enabled=True),
+                "image-vision": FileExtractorConfig(url="http://localhost/img", enabled=False)
+            },
+            extension_mapping={
+                ".pdf": "pdf-text",
+                ".png": "image-vision"
+            }
+        )
+
+        client = TestClient(app)
+        resp = client.get("/api/config", headers={"X-User-Email": "test@test.com"})
+
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["features"]["file_content_extraction"] is True
+        assert data["file_extraction"]["enabled"] is True
+        assert data["file_extraction"]["default_behavior"] == "full"
+        # Only .pdf should be in supported_extensions since image-vision is disabled
+        assert ".pdf" in data["file_extraction"]["supported_extensions"]
+        assert ".png" not in data["file_extraction"]["supported_extensions"]
+    finally:
+        config_manager.app_settings.feature_file_content_extraction_enabled = original_feature
+        config_manager._file_extractors_config = original_extractors
+
+
+def test_file_extraction_handles_config_errors_gracefully():
+    """File extraction config should handle errors gracefully."""
+    config_manager = app_factory.get_config_manager()
+    original_feature = config_manager.app_settings.feature_file_content_extraction_enabled
+    original_extractors = config_manager._file_extractors_config
+
+    try:
+        config_manager.app_settings.feature_file_content_extraction_enabled = True
+
+        # Force an error by setting invalid config that will cause exception
+        config_manager._file_extractors_config = None
+
+        # Patch the property to raise an exception
+        with patch.object(
+            type(config_manager),
+            'file_extractors_config',
+            property(lambda self: (_ for _ in ()).throw(Exception("Config error")))
+        ):
+            client = TestClient(app)
+            resp = client.get("/api/config", headers={"X-User-Email": "test@test.com"})
+
+            assert resp.status_code == 200
+            data = resp.json()
+            # Should return safe defaults on error
+            assert data["file_extraction"]["enabled"] is False
+            assert data["file_extraction"]["default_behavior"] == "none"
+            assert data["file_extraction"]["supported_extensions"] == []
+    finally:
+        config_manager.app_settings.feature_file_content_extraction_enabled = original_feature
+        config_manager._file_extractors_config = original_extractors
+
+
+def test_file_extraction_extensions_sorted():
+    """File extraction supported extensions should be sorted."""
+    config_manager = app_factory.get_config_manager()
+    original_feature = config_manager.app_settings.feature_file_content_extraction_enabled
+    original_extractors = config_manager._file_extractors_config
+
+    try:
+        config_manager.app_settings.feature_file_content_extraction_enabled = True
+        config_manager._file_extractors_config = FileExtractorsConfig(
+            enabled=True,
+            extractors={
+                "pdf-text": FileExtractorConfig(url="http://localhost/pdf", enabled=True)
+            },
+            extension_mapping={
+                ".pdf": "pdf-text",
+                ".doc": "pdf-text",
+                ".txt": "pdf-text"
+            }
+        )
+
+        client = TestClient(app)
+        resp = client.get("/api/config", headers={"X-User-Email": "test@test.com"})
+
+        assert resp.status_code == 200
+        data = resp.json()
+        extensions = data["file_extraction"]["supported_extensions"]
+        assert extensions == sorted(extensions)
+    finally:
+        config_manager.app_settings.feature_file_content_extraction_enabled = original_feature
+        config_manager._file_extractors_config = original_extractors

atlas/tests/test_file_library.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+Unit tests for File Library implementation.
+Tests the new file library feature including:
+- AllFilesView component functionality
+- SessionFilesView component
+- FileManagerPanel tab switching
+- Backend attach_file endpoint
+- WebSocket attach_file message handling
+"""
+
+
+
+# Test the backend attach_file functionality
+class TestAttachFileBackend:
+    def test_handle_attach_file_success(self):
+        """Test successful file attachment to session"""
+        # This would be a full integration test when backend is running
+        pass
+
+    def test_handle_attach_file_file_not_found(self):
+        """Test handling of file not found error"""
+        pass
+
+    def test_handle_attach_file_unauthorized(self):
+        """Test handling of unauthorized access"""
+        pass
+
+# Frontend component tests would go here
+# These would typically use a testing framework like Jest or Vitest
+
+class TestAllFilesView:
+    def test_fetch_all_files(self):
+        """Test fetching all user files"""
+        pass
+
+    def test_search_filter(self):
+        """Test file search functionality"""
+        pass
+
+    def test_sort_functionality(self):
+        """Test file sorting by different criteria"""
+        pass
+
+    def test_type_filter(self):
+        """Test filtering by file type (uploaded vs generated)"""
+        pass
+
+    def test_load_to_session(self):
+        """Test loading file to current session"""
+        pass
+
+    def test_download_file(self):
+        """Test file download functionality"""
+        pass
+
+    def test_delete_file(self):
+        """Test file deletion"""
+        pass
+
+class TestSessionFilesView:
+    def test_display_session_files(self):
+        """Test displaying files in current session"""
+        pass
+
+    def test_file_actions(self):
+        """Test download, delete, and tagging actions"""
+        pass
+
+class TestFileManagerPanel:
+    def test_tab_switching(self):
+        """Test switching between Session Files and File Library tabs"""
+        pass
+
+    def test_initial_tab_state(self):
+        """Test that panel opens on Session Files tab by default"""
+        pass
+
+# Integration test scenarios
+class TestFileLibraryIntegration:
+    def test_end_to_end_workflow(self):
+        """
+        Test end-to-end workflow:
+        1. Upload file in session A
+        2. Start new session B
+        3. Open File Library tab
+        4. Search for and find file from session A
+        5. Load file into session B
+        6. Verify file appears in Session Files
+        """
+        pass
+
+if __name__ == "__main__":
+    print("File Library unit tests")
+    print("Note: Most testing should be done manually through the UI")
+    print("because the functionality primarily involves user interaction.")
+    print("")
+    print("Manual testing checklist:")
+    print("- Open File Manager panel")
+    print("- Switch between 'Session Files' and 'File Library' tabs")
+    print("- Verify files are displayed correctly in each tab")
+    print("- Search, filter, and sort files in File Library")
+    print("- Download files from File Library")
+    print("- Delete files from File Library")
+    print("- Load files from File Library to current session")
+    print("- Verify loaded files appear in Session Files tab")
+    print("- Test error handling for failed operations")

atlas/tests/test_file_manager_unit.py

@@ -0,0 +1,18 @@
+
+from atlas.modules.file_storage.manager import FileManager
+
+
+def test_file_manager_content_type_and_category():
+    fm = FileManager(s3_client=None)  # will construct default
+
+    assert fm.get_content_type("report.pdf") == "application/pdf"
+    assert fm.get_content_type("diagram.png") == "image/png"
+    assert fm.get_content_type("unknown.bin") == "application/octet-stream"
+
+    assert fm.categorize_file_type("main.py") == "code"
+    assert fm.categorize_file_type("photo.jpg") == "image"
+    assert fm.categorize_file_type("data.csv") == "data"
+    assert fm.categorize_file_type("notes.txt") == "document"
+
+    assert fm.should_display_in_canvas("plot.png") is True
+    assert fm.should_display_in_canvas("archive.zip") is False

atlas/tests/test_health_route.py

@@ -0,0 +1,49 @@
+"""Unit tests for health check endpoint."""
+
+from datetime import datetime
+
+from main import app
+from starlette.testclient import TestClient
+
+
+def test_health_endpoint_returns_200():
+    """Test that health endpoint returns 200 status."""
+    client = TestClient(app)
+    resp = client.get("/api/health")
+    assert resp.status_code == 200
+
+
+def test_health_endpoint_no_auth_required():
+    """Test that health endpoint works without authentication."""
+    client = TestClient(app)
+    # No X-User-Email header provided
+    resp = client.get("/api/health")
+    assert resp.status_code == 200
+
+
+def test_health_endpoint_response_structure():
+    """Test that health endpoint returns correct response structure."""
+    client = TestClient(app)
+    resp = client.get("/api/health")
+    assert resp.status_code == 200
+
+    data = resp.json()
+
+    # Verify all required fields are present
+    assert "status" in data
+    assert "service" in data
+    assert "version" in data
+    assert "timestamp" in data
+
+    # Verify field values
+    assert data["status"] == "healthy"
+    assert data["service"] == "atlas-ui-3-backend"
+
+    # This version number can change, so just check it's a non-empty string
+    assert isinstance(data["version"], str) and len(data["version"]) > 0
+
+    # Verify timestamp is valid ISO-8601 format
+    try:
+        datetime.fromisoformat(data["timestamp"])
+    except ValueError:
+        assert False, f"Invalid timestamp format: {data['timestamp']}"

atlas/tests/test_http_client_stub.py

@@ -0,0 +1,8 @@
+from atlas.core.http_client import create_rag_client
+
+
+def test_http_client_stub_returns_object():
+    client = create_rag_client("http://example", 5.0)
+    assert client is not None
+    # ensure object has query coroutine
+    assert hasattr(client, "query")

atlas/tests/test_imports_smoke.py

@@ -0,0 +1,30 @@
+import pkgutil
+import sys
+from pathlib import Path
+
+# Import all backend python modules to catch import-time errors quickly.
+# Skip heavy runtime side effects by not executing app.run, etc.
+
+def iter_backend_modules():
+    backend_root = Path(__file__).resolve().parents[1]
+    sys.path.insert(0, str(backend_root))
+
+    for module in pkgutil.walk_packages([str(backend_root)], prefix=""):
+        name = module.name
+        # Skip private and test packages
+        if name.startswith("tests"):
+            continue
+        # Skip MCP servers as they may require external binaries
+        if name.startswith("mcp.") or name.startswith("mcp/"):
+            continue
+        yield name
+
+
+def test_import_all_backend_modules():
+    failed = []
+    for name in iter_backend_modules():
+        try:
+            __import__(name)
+        except Exception as e:
+            failed.append((name, str(e)))
+    assert not failed, f"Import failures: {failed[:5]} (and {max(0, len(failed)-5)} more)"

atlas/tests/test_interfaces_llm_response.py

@@ -0,0 +1,9 @@
+from atlas.interfaces.llm import LLMResponse
+
+
+def test_llm_response_has_tool_calls():
+    r1 = LLMResponse(content="hello", tool_calls=None)
+    assert r1.has_tool_calls() is False
+
+    r2 = LLMResponse(content="hi", tool_calls=[{"type": "function", "function": {"name": "t"}}])
+    assert r2.has_tool_calls() is True

atlas/tests/test_issue_access_denied_fix.py

@@ -0,0 +1,136 @@
+"""
+Integration test demonstrating the fix for the access denied issue.
+
+This test simulates the exact scenario from the issue:
+- A file belongs to user 'agarlan@sandia.gov'
+- WebSocket connection is authenticated as 'agarlan@sandia.gov' via X-User-Email header
+- Attaching the file should succeed (not fail with "Access denied")
+"""
+
+import base64
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi.testclient import TestClient
+from main import app
+
+
+@pytest.fixture
+def mock_components():
+    """Mock all components needed for the test."""
+    with patch('main.app_factory') as mock_factory:
+        # Mock config
+        mock_config = MagicMock()
+        mock_config.app_settings.test_user = 'test@test.com'
+        mock_config.app_settings.auth_user_header = 'X-User-Email'
+        mock_factory.get_config_manager.return_value = mock_config
+
+        # Mock file manager with S3 client
+        mock_file_manager = MagicMock()
+        mock_s3_client = MagicMock()
+
+        # Simulate a file that belongs to agarlan@sandia.gov
+        async def mock_get_file(user_email, s3_key):
+            """Mock S3 get_file that enforces user prefix check."""
+            # This is the actual check from s3_client.py line 185
+            if not s3_key.startswith(f"users/{user_email}/"):
+                raise Exception("Access denied to file")
+
+            # If user matches, return file metadata
+            return {
+                "key": s3_key,
+                "filename": "mypdf.pdf",
+                "content_base64": base64.b64encode(b"test content").decode(),
+                "content_type": "application/pdf",
+                "size": 100,
+                "etag": "test-etag"
+            }
+
+        mock_s3_client.get_file = AsyncMock(side_effect=mock_get_file)
+        mock_file_manager.s3_client = mock_s3_client
+
+        # Mock chat service
+        mock_chat_service = MagicMock()
+        mock_chat_service.handle_attach_file = AsyncMock(return_value={
+            'type': 'file_attach',
+            'success': True,
+            'filename': 'mypdf.pdf'
+        })
+        mock_chat_service.end_session = MagicMock()
+        mock_factory.create_chat_service.return_value = mock_chat_service
+
+        yield {
+            'factory': mock_factory,
+            'config': mock_config,
+            'file_manager': mock_file_manager,
+            'chat_service': mock_chat_service
+        }
+
+
+def test_issue_scenario_fixed_with_correct_user(mock_components):
+    """
+    Test the exact scenario from the issue, demonstrating the fix.
+
+    Before fix:
+    - WebSocket would use test@test.com (from fallback)
+    - Attempting to access users/agarlan@sandia.gov/generated/file.pdf would fail
+    - Error: "Access denied: test@test.com attempted to access users/agarlan@sandia.gov/..."
+
+    After fix:
+    - WebSocket uses agarlan@sandia.gov (from X-User-Email header)
+    - Accessing users/agarlan@sandia.gov/generated/file.pdf succeeds
+    """
+    client = TestClient(app)
+
+    # Simulate the production scenario: reverse proxy sets X-User-Email header
+    actual_user = "agarlan@sandia.gov"
+
+    # Connect with X-User-Email header (as set by reverse proxy)
+    with client.websocket_connect("/ws", headers={"X-User-Email": actual_user}):
+        # Verify the connection was created with the correct user
+        call_args = mock_components['factory'].create_chat_service.call_args
+        connection_adapter = call_args[0][0]
+
+        # This should be the actual user, not test@test.com
+        assert connection_adapter.user_email == actual_user, (
+            f"Expected user to be {actual_user}, but got {connection_adapter.user_email}. "
+            "This would cause 'Access denied' errors when accessing user's files."
+        )
+
+
+def test_issue_scenario_would_fail_without_header():
+    """
+    Demonstrate that without the header, the old behavior (test user fallback) occurs.
+    This test shows why the issue existed in the first place.
+    """
+    with patch('main.app_factory') as mock_factory:
+        # Mock config
+        mock_config = MagicMock()
+        mock_config.app_settings.test_user = 'test@test.com'
+        mock_config.app_settings.auth_user_header = 'X-User-Email'
+        mock_factory.get_config_manager.return_value = mock_config
+
+        # Mock chat service
+        mock_chat_service = MagicMock()
+        mock_chat_service.end_session = MagicMock()
+        mock_factory.create_chat_service.return_value = mock_chat_service
+
+        client = TestClient(app)
+
+        # Connect WITHOUT X-User-Email header (simulating old behavior or dev mode)
+        with client.websocket_connect("/ws"):
+            call_args = mock_factory.create_chat_service.call_args
+            connection_adapter = call_args[0][0]
+
+            # Without header, it falls back to test user
+            assert connection_adapter.user_email == 'test@test.com', (
+                "Without X-User-Email header, should fall back to test user"
+            )
+
+            # This would cause access denied when trying to access:
+            # users/agarlan@sandia.gov/generated/file.pdf
+            # because connection is authenticated as test@test.com
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])