atlas-chat 0.1.0__py3-none-any.whl

atlas/tests/test_env_demo_server.py

@@ -0,0 +1,88 @@
+"""
+Unit tests for the env-demo MCP server.
+Tests the environment variable demonstration functionality.
+"""
+import os
+
+import pytest
+
+
+# Test that the server can be imported
+def test_server_imports():
+    """Test that the env-demo server module can be imported."""
+    try:
+        import sys
+        sys.path.insert(0, '/home/runner/work/atlas-ui-3/atlas-ui-3/backend')
+        # Import the module by file path since directory has hyphen
+        import importlib.util
+        spec = importlib.util.spec_from_file_location(
+            "env_demo_main",
+            "/home/runner/work/atlas-ui-3/atlas-ui-3/backend/mcp/env-demo/main.py"
+        )
+        module = importlib.util.module_from_spec(spec)
+        # Don't execute - just verify it can be loaded
+        assert spec is not None
+        assert module is not None
+    except Exception as e:
+        pytest.fail(f"Failed to import env-demo server: {e}")
+
+
+def test_env_var_configuration():
+    """Test that environment variables are accessible."""
+    # Set test environment variables
+    os.environ["TEST_CLOUD_PROFILE"] = "test-profile"
+    os.environ["TEST_CLOUD_REGION"] = "test-region"
+
+    # Verify they can be read
+    assert os.environ.get("TEST_CLOUD_PROFILE") == "test-profile"
+    assert os.environ.get("TEST_CLOUD_REGION") == "test-region"
+
+    # Clean up
+    del os.environ["TEST_CLOUD_PROFILE"]
+    del os.environ["TEST_CLOUD_REGION"]
+
+
+def test_env_var_substitution_pattern():
+    """Test the ${VAR} pattern that should be resolved by config_manager."""
+    # This tests the pattern that config_manager.resolve_env_var handles
+    # We test the pattern matching logic directly
+    import re
+
+    # Set a test variable
+    os.environ["TEST_API_KEY"] = "secret-123"
+
+    # Test the ${VAR} pattern matching (same as config_manager.resolve_env_var)
+    pattern = r'\$\{([A-Za-z_][A-Za-z0-9_]*)\}'
+
+    # Test resolution
+    test_value = "${TEST_API_KEY}"
+    match = re.match(pattern, test_value)
+    assert match is not None
+    var_name = match.group(1)
+    assert var_name == "TEST_API_KEY"
+    resolved = os.environ.get(var_name)
+    assert resolved == "secret-123"
+
+    # Test literal value (no substitution)
+    test_value = "literal-value"
+    match = re.match(pattern, test_value)
+    assert match is None  # Should not match
+
+    # Test missing variable
+    test_value = "${MISSING_VAR}"
+    match = re.match(pattern, test_value)
+    assert match is not None
+    var_name = match.group(1)
+    assert var_name == "MISSING_VAR"
+    missing_var = os.environ.get(var_name)
+    assert missing_var is None  # Variable doesn't exist
+
+    # Clean up
+    del os.environ["TEST_API_KEY"]
+
+
+
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

atlas/tests/test_error_classification.py

@@ -0,0 +1,113 @@
+"""Tests for error classification and user-friendly error messages."""
+
+from atlas.application.chat.utilities.error_handler import classify_llm_error
+from atlas.domain.errors import LLMAuthenticationError, LLMServiceError, LLMTimeoutError, RateLimitError
+
+
+class TestErrorClassification:
+    """Test error classification for LLM errors."""
+
+    def test_classify_rate_limit_error_by_type_name(self):
+        """Test classification of rate limit errors by exception type name."""
+        # Create a custom exception class to test type name detection
+        class RateLimitError(Exception):
+            pass
+
+        error = RateLimitError("Some error message")
+
+        from atlas.domain.errors import RateLimitError as DomainRateLimitError
+        error_class, user_msg, log_msg = classify_llm_error(error)
+
+        assert error_class == DomainRateLimitError
+        assert "high traffic" in user_msg.lower()
+        assert "try again" in user_msg.lower()
+        assert "rate limit" in log_msg.lower()
+
+    def test_classify_rate_limit_error_by_message_content(self):
+        """Test classification of rate limit errors by message content."""
+        error = Exception("We're experiencing high traffic right now! Please try again soon.")
+
+        error_class, user_msg, log_msg = classify_llm_error(error)
+
+        assert error_class == RateLimitError
+        assert "high traffic" in user_msg.lower()
+        assert "try again" in user_msg.lower()
+
+    def test_classify_rate_limit_error_alternative_message(self):
+        """Test classification of rate limit errors with alternative wording."""
+        error = Exception("Rate limit exceeded for this API key")
+
+        error_class, user_msg, log_msg = classify_llm_error(error)
+
+        assert error_class == RateLimitError
+        assert "try again" in user_msg.lower()
+
+    def test_classify_timeout_error(self):
+        """Test classification of timeout errors."""
+        error = Exception("Request timed out after 30 seconds")
+
+        error_class, user_msg, log_msg = classify_llm_error(error)
+
+        assert error_class == LLMTimeoutError
+        assert "timeout" in user_msg.lower() or "timed out" in user_msg.lower()
+        assert "try again" in user_msg.lower()
+
+    def test_classify_authentication_error(self):
+        """Test classification of authentication errors."""
+        error = Exception("Invalid API key provided")
+
+        error_class, user_msg, log_msg = classify_llm_error(error)
+
+        assert error_class == LLMAuthenticationError
+        assert "authentication" in user_msg.lower()
+        assert "administrator" in user_msg.lower()
+
+    def test_classify_unauthorized_error(self):
+        """Test classification of unauthorized errors."""
+        error = Exception("Unauthorized access")
+
+        error_class, user_msg, log_msg = classify_llm_error(error)
+
+        assert error_class == LLMAuthenticationError
+        assert "authentication" in user_msg.lower()
+
+    def test_classify_generic_llm_error(self):
+        """Test classification of generic LLM errors."""
+        error = Exception("Something went wrong with the model")
+
+        error_class, user_msg, log_msg = classify_llm_error(error)
+
+        assert error_class == LLMServiceError
+        assert "error" in user_msg.lower()
+        assert "try again" in user_msg.lower() or "contact support" in user_msg.lower()
+
+    def test_error_messages_are_user_friendly(self):
+        """Test that all error messages are user-friendly (no technical details)."""
+        test_errors = [
+            Exception("RateLimitError: Rate limit exceeded"),
+            Exception("Request timeout after 60s"),
+            Exception("Invalid API key: abc123"),
+            Exception("Unknown model error"),
+        ]
+
+        for error in test_errors:
+            _, user_msg, _ = classify_llm_error(error)
+
+            # User messages should be helpful and not expose technical details
+            assert len(user_msg) > 20  # Should be a complete sentence
+            # Technical details should not appear in user message
+            technical_substrings = ["RateLimitError:", "abc123", "stack trace"]
+            for technical in technical_substrings:
+                assert technical not in user_msg, f"User message should not contain technical detail: {technical}"
+            assert user_msg[0].isupper()  # Starts with capital letter
+            assert user_msg.endswith(".")  # Ends with period
+
+    def test_log_messages_contain_error_details(self):
+        """Test that log messages contain error details for debugging."""
+        error = Exception("RateLimitError: We're experiencing high traffic")
+
+        _, _, log_msg = classify_llm_error(error)
+
+        # Log message should contain the actual error for debugging
+        assert "high traffic" in log_msg.lower()
+        assert len(log_msg) > 10

atlas/tests/test_error_flow_integration.py

@@ -0,0 +1,116 @@
+"""Integration test for error flow from LLM to WebSocket."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from atlas.domain.errors import LLMAuthenticationError, LLMTimeoutError, RateLimitError
+
+
+class TestErrorFlowIntegration:
+    """Test that errors flow correctly from LLM through to error responses."""
+
+    @pytest.mark.asyncio
+    async def test_rate_limit_error_flow(self):
+        """Test that rate limit errors result in proper user-friendly messages."""
+        from atlas.application.chat.utilities.error_handler import safe_call_llm_with_tools
+
+        # Mock LLM caller that raises a rate limit error
+        mock_llm = MagicMock()
+        mock_llm.call_with_tools = AsyncMock(
+            side_effect=Exception("RateLimitError: We're experiencing high traffic right now! Please try again soon.")
+        )
+
+        # Call should raise our custom RateLimitError
+        with pytest.raises(RateLimitError) as exc_info:
+            await safe_call_llm_with_tools(
+                llm_caller=mock_llm,
+                model="test-model",
+                messages=[{"role": "user", "content": "test"}],
+                tools_schema=[],
+            )
+
+        # Verify the error message is user-friendly
+        error_msg = str(exc_info.value.message if hasattr(exc_info.value, 'message') else exc_info.value)
+        assert "high traffic" in error_msg.lower()
+        assert "try again" in error_msg.lower()
+        # Should NOT contain technical details
+        assert "RateLimitError:" not in error_msg
+
+    @pytest.mark.asyncio
+    async def test_timeout_error_flow(self):
+        """Test that timeout errors result in proper user-friendly messages."""
+        from atlas.application.chat.utilities.error_handler import safe_call_llm_with_tools
+
+        # Mock LLM caller that raises a timeout error
+        mock_llm = MagicMock()
+        mock_llm.call_with_tools = AsyncMock(
+            side_effect=Exception("Request timed out after 60 seconds")
+        )
+
+        # Call should raise our custom LLMTimeoutError
+        with pytest.raises(LLMTimeoutError) as exc_info:
+            await safe_call_llm_with_tools(
+                llm_caller=mock_llm,
+                model="test-model",
+                messages=[{"role": "user", "content": "test"}],
+                tools_schema=[],
+            )
+
+        # Verify the error message is user-friendly
+        error_msg = str(exc_info.value.message if hasattr(exc_info.value, 'message') else exc_info.value)
+        assert "timeout" in error_msg.lower() or "timed out" in error_msg.lower()
+        assert "try again" in error_msg.lower()
+
+    @pytest.mark.asyncio
+    async def test_authentication_error_flow(self):
+        """Test that authentication errors result in proper user-friendly messages."""
+        from atlas.application.chat.utilities.error_handler import safe_call_llm_with_tools
+
+        # Mock LLM caller that raises an auth error
+        mock_llm = MagicMock()
+        mock_llm.call_with_tools = AsyncMock(
+            side_effect=Exception("Invalid API key provided")
+        )
+
+        # Call should raise our custom LLMAuthenticationError
+        with pytest.raises(LLMAuthenticationError) as exc_info:
+            await safe_call_llm_with_tools(
+                llm_caller=mock_llm,
+                model="test-model",
+                messages=[{"role": "user", "content": "test"}],
+                tools_schema=[],
+            )
+
+        # Verify the error message is user-friendly
+        error_msg = str(exc_info.value.message if hasattr(exc_info.value, 'message') else exc_info.value)
+        assert "authentication" in error_msg.lower()
+        assert "administrator" in error_msg.lower()
+        # Should NOT contain the actual API key reference
+        assert "API key" not in error_msg and "api key" not in error_msg.lower()
+
+    @pytest.mark.asyncio
+    async def test_successful_llm_call(self):
+        """Test that successful LLM calls work normally."""
+        from atlas.application.chat.utilities.error_handler import safe_call_llm_with_tools
+        from atlas.interfaces.llm import LLMResponse
+
+        # Mock successful LLM response
+        mock_response = LLMResponse(
+            content="Test response",
+            model_used="test-model"
+        )
+
+        mock_llm = MagicMock()
+        mock_llm.call_with_tools = AsyncMock(return_value=mock_response)
+
+        # Call should succeed
+        result = await safe_call_llm_with_tools(
+            llm_caller=mock_llm,
+            model="test-model",
+            messages=[{"role": "user", "content": "test"}],
+            tools_schema=[],
+        )
+
+        assert result == mock_response
+        assert result.content == "Test response"

atlas/tests/test_feedback_routes.py

@@ -0,0 +1,333 @@
+"""Tests for feedback routes to prevent regression of issue #200.
+
+Verifies that:
+- POST /api/feedback is accessible to authenticated users
+- GET /api/feedback requires admin group membership
+- GET /api/feedback/stats requires admin group membership
+- DELETE /api/feedback/{id} requires admin group membership
+"""
+
+import json
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from main import app
+from starlette.testclient import TestClient
+
+AUTH_HEADERS = {"X-User-Email": "test@test.com"}
+ADMIN_HEADERS = {"X-User-Email": "admin@test.com"}
+
+
+@pytest.fixture
+def temp_feedback_dir():
+    """Create a temporary directory for feedback files."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        yield Path(tmpdir)
+
+
+@pytest.fixture
+def mock_feedback_dir(temp_feedback_dir, monkeypatch):
+    """Mock the feedback directory to use temp directory."""
+    def mock_get_feedback_directory():
+        return temp_feedback_dir
+
+    monkeypatch.setattr(
+        "atlas.routes.feedback_routes.get_feedback_directory",
+        mock_get_feedback_directory
+    )
+    return temp_feedback_dir
+
+
+@pytest.fixture
+def mock_admin_check():
+    """Mock admin group check to allow admin@test.com."""
+    async def mock_is_user_in_group(user: str, group: str) -> bool:
+        return user == "admin@test.com"
+
+    with patch("atlas.routes.feedback_routes.is_user_in_group", mock_is_user_in_group):
+        yield
+
+
+class TestFeedbackRouteRegistration:
+    """Test that feedback routes are properly registered (issue #200)."""
+
+    def test_post_feedback_route_exists(self):
+        """POST /api/feedback should not return 404."""
+        client = TestClient(app)
+        resp = client.post(
+            "/api/feedback",
+            json={"rating": 1, "comment": "test", "session": {}},
+            headers=AUTH_HEADERS
+        )
+        assert resp.status_code != 404, "Feedback route not registered (issue #200)"
+
+    def test_get_feedback_route_exists(self):
+        """GET /api/feedback should not return 404."""
+        client = TestClient(app)
+        resp = client.get("/api/feedback", headers=AUTH_HEADERS)
+        assert resp.status_code != 404, "Feedback route not registered (issue #200)"
+
+    def test_get_feedback_stats_route_exists(self):
+        """GET /api/feedback/stats should not return 404."""
+        client = TestClient(app)
+        resp = client.get("/api/feedback/stats", headers=AUTH_HEADERS)
+        assert resp.status_code != 404, "Feedback stats route not registered (issue #200)"
+
+
+class TestFeedbackSubmission:
+    """Test feedback submission by regular users."""
+
+    def test_submit_feedback_success(self, mock_feedback_dir, mock_admin_check):
+        """Regular users can submit feedback."""
+        client = TestClient(app)
+        resp = client.post(
+            "/api/feedback",
+            json={"rating": 1, "comment": "Great service!", "session": {"model": "gpt-4"}},
+            headers=AUTH_HEADERS
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["message"] == "Feedback submitted successfully"
+        assert "feedback_id" in data
+        assert "timestamp" in data
+
+    def test_submit_feedback_validates_rating(self, mock_feedback_dir, mock_admin_check):
+        """Feedback submission validates rating values."""
+        client = TestClient(app)
+        resp = client.post(
+            "/api/feedback",
+            json={"rating": 5, "comment": "Invalid rating"},
+            headers=AUTH_HEADERS
+        )
+        assert resp.status_code == 400
+        assert "Rating must be -1, 0, or 1" in resp.json()["detail"]
+
+    def test_submit_feedback_creates_file(self, mock_feedback_dir, mock_admin_check):
+        """Feedback submission creates a JSON file."""
+        client = TestClient(app)
+        resp = client.post(
+            "/api/feedback",
+            json={"rating": 0, "comment": "Neutral feedback"},
+            headers=AUTH_HEADERS
+        )
+        assert resp.status_code == 200
+
+        feedback_files = list(mock_feedback_dir.glob("feedback_*.json"))
+        assert len(feedback_files) == 1
+
+        with open(feedback_files[0]) as f:
+            saved_data = json.load(f)
+        assert saved_data["rating"] == 0
+        assert saved_data["comment"] == "Neutral feedback"
+        assert saved_data["user"] == "test@test.com"
+
+
+class TestFeedbackAdminAccess:
+    """Test that viewing feedback requires admin access."""
+
+    def test_get_feedback_requires_admin(self, mock_feedback_dir, mock_admin_check):
+        """GET /api/feedback returns 403 for non-admin users."""
+        client = TestClient(app)
+        resp = client.get("/api/feedback", headers=AUTH_HEADERS)
+        assert resp.status_code == 403
+        assert "Admin access required" in resp.json()["detail"]
+
+    def test_get_feedback_stats_requires_admin(self, mock_feedback_dir, mock_admin_check):
+        """GET /api/feedback/stats returns 403 for non-admin users."""
+        client = TestClient(app)
+        resp = client.get("/api/feedback/stats", headers=AUTH_HEADERS)
+        assert resp.status_code == 403
+        assert "Admin access required" in resp.json()["detail"]
+
+    def test_admin_can_view_feedback(self, mock_feedback_dir, mock_admin_check):
+        """Admin users can view feedback list."""
+        client = TestClient(app)
+
+        client.post(
+            "/api/feedback",
+            json={"rating": 1, "comment": "Test"},
+            headers=AUTH_HEADERS
+        )
+
+        resp = client.get("/api/feedback", headers=ADMIN_HEADERS)
+        assert resp.status_code == 200
+        data = resp.json()
+        assert "feedback" in data
+        assert "pagination" in data
+        assert "statistics" in data
+
+    def test_admin_can_view_stats(self, mock_feedback_dir, mock_admin_check):
+        """Admin users can view feedback statistics."""
+        client = TestClient(app)
+        resp = client.get("/api/feedback/stats", headers=ADMIN_HEADERS)
+        assert resp.status_code == 200
+        data = resp.json()
+        assert "total_feedback" in data
+        assert "rating_distribution" in data
+
+
+class TestFeedbackDeletion:
+    """Test feedback deletion by admin."""
+
+    def test_delete_feedback_requires_admin(self, mock_feedback_dir, mock_admin_check):
+        """DELETE /api/feedback/{id} returns 403 for non-admin users."""
+        client = TestClient(app)
+        resp = client.delete("/api/feedback/fake-id", headers=AUTH_HEADERS)
+        assert resp.status_code == 403
+
+    def test_admin_can_delete_feedback(self, mock_feedback_dir, mock_admin_check):
+        """Admin users can delete feedback."""
+        client = TestClient(app)
+
+        resp = client.post(
+            "/api/feedback",
+            json={"rating": -1, "comment": "To be deleted"},
+            headers=AUTH_HEADERS
+        )
+        feedback_id = resp.json()["feedback_id"]
+
+        resp = client.delete(f"/api/feedback/{feedback_id}", headers=ADMIN_HEADERS)
+        assert resp.status_code == 200
+        assert resp.json()["message"] == "Feedback deleted successfully"
+
+    def test_delete_nonexistent_feedback_returns_404(self, mock_feedback_dir, mock_admin_check):
+        """Deleting non-existent feedback returns 404."""
+        client = TestClient(app)
+        resp = client.delete("/api/feedback/nonexistent", headers=ADMIN_HEADERS)
+        assert resp.status_code == 404
+
+
+class TestFeedbackDownload:
+    """Test feedback download functionality."""
+
+    def test_download_feedback_requires_admin(self, mock_feedback_dir, mock_admin_check):
+        """GET /api/feedback/download returns 403 for non-admin users."""
+        client = TestClient(app)
+        resp = client.get("/api/feedback/download", headers=AUTH_HEADERS)
+        assert resp.status_code == 403
+
+    def test_download_feedback_csv_format(self, mock_feedback_dir, mock_admin_check):
+        """Admin users can download feedback as CSV."""
+        client = TestClient(app)
+
+        # Create some test feedback
+        client.post(
+            "/api/feedback",
+            json={"rating": 1, "comment": "Great service!", "session": {"model": "gpt-4"}},
+            headers=AUTH_HEADERS
+        )
+        client.post(
+            "/api/feedback",
+            json={"rating": -1, "comment": "Poor experience", "session": {"model": "gpt-3"}},
+            headers=AUTH_HEADERS
+        )
+
+        # Download as CSV
+        resp = client.get("/api/feedback/download?format=csv", headers=ADMIN_HEADERS)
+        assert resp.status_code == 200
+        assert resp.headers["content-type"] == "text/csv; charset=utf-8"
+        assert "attachment; filename=" in resp.headers["content-disposition"]
+        assert "feedback_export_" in resp.headers["content-disposition"]
+
+        # Verify CSV content
+        csv_content = resp.text
+        lines = [line.strip() for line in csv_content.strip().split('\n') if line.strip()]
+        assert len(lines) >= 3  # Header + 2 data rows
+
+        # Check header
+        assert lines[0] == "id,timestamp,user,rating,comment"
+
+        # Check that feedback appears in CSV (order may vary)
+        found_positive = any("1" in line and "Great service!" in line for line in lines[1:])
+        found_negative = any("-1" in line and "Poor experience" in line for line in lines[1:])
+        assert found_positive, "Positive feedback not found in CSV"
+        assert found_negative, "Negative feedback not found in CSV"
+
+    def test_download_feedback_json_format(self, mock_feedback_dir, mock_admin_check):
+        """Admin users can download feedback as JSON."""
+        client = TestClient(app)
+
+        # Create test feedback
+        resp1 = client.post(
+            "/api/feedback",
+            json={"rating": 1, "comment": "JSON test", "session": {"model": "gpt-4"}},
+            headers=AUTH_HEADERS
+        )
+        feedback_id = resp1.json()["feedback_id"]
+
+        # Download as JSON
+        resp = client.get("/api/feedback/download?format=json", headers=ADMIN_HEADERS)
+        assert resp.status_code == 200
+        assert resp.headers["content-type"] == "application/json"
+        assert "attachment; filename=" in resp.headers["content-disposition"]
+        assert "feedback_export_" in resp.headers["content-disposition"]
+
+        # Verify JSON content
+        json_data = resp.json()
+        assert isinstance(json_data, list)
+        assert len(json_data) == 1
+
+        feedback = json_data[0]
+        assert feedback["id"] == feedback_id
+        assert feedback["rating"] == 1
+        assert feedback["comment"] == "JSON test"
+        assert feedback["user"] == "test@test.com"
+        assert "timestamp" in feedback
+        assert "session_info" in feedback
+        assert "server_context" in feedback
+
+    def test_download_feedback_empty_csv(self, mock_feedback_dir, mock_admin_check):
+        """Downloading empty feedback as CSV returns header-only file."""
+        client = TestClient(app)
+
+        resp = client.get("/api/feedback/download?format=csv", headers=ADMIN_HEADERS)
+        assert resp.status_code == 200
+
+        csv_content = resp.text
+        lines = csv_content.strip().split('\n')
+        assert len(lines) == 1  # Only header row
+        assert lines[0] == "id,timestamp,user,rating,comment"
+
+    def test_download_feedback_empty_json(self, mock_feedback_dir, mock_admin_check):
+        """Downloading empty feedback as JSON returns empty array."""
+        client = TestClient(app)
+
+        resp = client.get("/api/feedback/download?format=json", headers=ADMIN_HEADERS)
+        assert resp.status_code == 200
+
+        json_data = resp.json()
+        assert json_data == []
+
+    def test_download_feedback_csv_sanitizes_fields(self, mock_feedback_dir, mock_admin_check):
+        """CSV download properly handles missing fields with defaults."""
+        client = TestClient(app)
+
+        # Clear any existing feedback files
+        for f in mock_feedback_dir.glob("feedback_*.json"):
+            f.unlink()
+
+        # Manually create feedback file with missing fields (using correct naming pattern)
+        import json
+        feedback_file = mock_feedback_dir / "feedback_manual_test123.json"
+        manual_feedback = {
+            "id": "test123",
+            "timestamp": "2026-01-10T12:00:00",
+            "user": "test@example.com"
+            # Missing rating, comment, session_info, server_context
+        }
+        with open(feedback_file, 'w') as f:
+            json.dump(manual_feedback, f)
+
+        resp = client.get("/api/feedback/download?format=csv", headers=ADMIN_HEADERS)
+        assert resp.status_code == 200
+
+        csv_content = resp.text
+        lines = csv_content.strip().split('\n')
+        assert len(lines) == 2  # Header + 1 data row
+
+        data_line = lines[1]
+        assert "test123" in data_line
+        assert "test@example.com" in data_line
+        # Missing fields should be empty strings