atlas-chat 0.1.0__py3-none-any.whl

atlas/tests/test_core_utils.py

@@ -0,0 +1,190 @@
+from types import SimpleNamespace
+
+import pytest
+
+from atlas.core.log_sanitizer import get_current_user, sanitize_for_logging
+
+
+@pytest.mark.asyncio
+async def test_get_current_user_default():
+    class Dummy:
+        pass
+    req = SimpleNamespace(state=SimpleNamespace())
+    assert await get_current_user(req) == "test@test.com"
+
+
+@pytest.mark.asyncio
+async def test_get_current_user_from_state():
+    req = SimpleNamespace(state=SimpleNamespace(user_email="user@example.com"))
+    assert await get_current_user(req) == "user@example.com"
+
+
+class TestSanitizeForLogging:
+    """Test suite for sanitize_for_logging function."""
+
+    def test_clean_string_unchanged(self):
+        """Test that strings without control characters are unchanged."""
+        assert sanitize_for_logging("Hello World") == "Hello World"
+        assert sanitize_for_logging("test123") == "test123"
+        assert sanitize_for_logging("user@example.com") == "user@example.com"
+
+    def test_removes_newlines(self):
+        """Test that newlines are removed."""
+        assert sanitize_for_logging("Hello\nWorld") == "HelloWorld"
+        assert sanitize_for_logging("Line1\nLine2\nLine3") == "Line1Line2Line3"
+        assert sanitize_for_logging("\nStarting newline") == "Starting newline"
+        assert sanitize_for_logging("Trailing newline\n") == "Trailing newline"
+
+    def test_removes_tabs(self):
+        """Test that tabs are removed."""
+        assert sanitize_for_logging("Hello\tWorld") == "HelloWorld"
+        assert sanitize_for_logging("\tIndented") == "Indented"
+
+    def test_removes_carriage_returns(self):
+        """Test that carriage returns are removed."""
+        assert sanitize_for_logging("Hello\rWorld") == "HelloWorld"
+        assert sanitize_for_logging("Windows\r\nLine") == "WindowsLine"
+
+    def test_removes_ansi_escape_sequences(self):
+        """Test that ANSI escape sequences are removed."""
+        # ANSI color codes
+        assert sanitize_for_logging("\x1b[31mRed Text\x1b[0m") == "[31mRed Text[0m"
+        assert sanitize_for_logging("\x1b[1;32mBold Green\x1b[0m") == "[1;32mBold Green[0m"
+
+    def test_removes_null_bytes(self):
+        """Test that null bytes are removed."""
+        assert sanitize_for_logging("Hello\x00World") == "HelloWorld"
+        assert sanitize_for_logging("\x00\x00test\x00") == "test"
+
+    def test_removes_control_characters(self):
+        """Test that various control characters are removed."""
+        # Test C0 control characters (0x00-0x1f)
+        assert sanitize_for_logging("Test\x01\x02\x03") == "Test"
+        assert sanitize_for_logging("\x07Bell\x08Backspace") == "BellBackspace"
+
+        # Test DEL character (0x7f)
+        assert sanitize_for_logging("Test\x7fDEL") == "TestDEL"
+
+        # Test C1 control characters (0x80-0x9f)
+        assert sanitize_for_logging("Test\x80\x81\x9f") == "Test"
+
+    def test_empty_string(self):
+        """Test that empty string returns empty string."""
+        assert sanitize_for_logging("") == ""
+
+    def test_none_value(self):
+        """Test that None returns empty string."""
+        assert sanitize_for_logging(None) == ""
+
+    def test_integer_value(self):
+        """Test that integers are converted to string."""
+        assert sanitize_for_logging(123) == "123"
+        assert sanitize_for_logging(0) == "0"
+        assert sanitize_for_logging(-456) == "-456"
+
+    def test_float_value(self):
+        """Test that floats are converted to string."""
+        assert sanitize_for_logging(3.14) == "3.14"
+        assert sanitize_for_logging(-0.5) == "-0.5"
+
+    def test_boolean_value(self):
+        """Test that booleans are converted to string."""
+        assert sanitize_for_logging(True) == "True"
+        assert sanitize_for_logging(False) == "False"
+
+    def test_list_value(self):
+        """Test that lists are converted to string."""
+        assert sanitize_for_logging([1, 2, 3]) == "[1, 2, 3]"
+        assert sanitize_for_logging(["a", "b"]) == "['a', 'b']"
+
+    def test_dict_value(self):
+        """Test that dicts are converted to string."""
+        result = sanitize_for_logging({"key": "value"})
+        assert "key" in result and "value" in result
+
+    def test_unicode_strings(self):
+        """Test that unicode strings are handled correctly."""
+        assert sanitize_for_logging("Hello 世界") == "Hello 世界"
+        assert sanitize_for_logging("Café ☕") == "Café ☕"
+        assert sanitize_for_logging("Test\n世界") == "Test世界"
+
+    def test_mixed_control_characters(self):
+        """Test strings with multiple types of control characters."""
+        assert sanitize_for_logging("Line1\r\nLine2\tTab\x00Null") == "Line1Line2TabNull"
+        assert sanitize_for_logging("\x01\x02Test\n\rData\x7f\x80") == "TestData"
+
+    def test_log_injection_attempt(self):
+        """Test that log injection attempts are sanitized."""
+        # Simulate log injection attack
+        malicious_input = "admin\n[INFO] Fake log entry\nAnother line"
+        sanitized = sanitize_for_logging(malicious_input)
+        assert "\n" not in sanitized
+        assert sanitized == "admin[INFO] Fake log entryAnother line"
+
+    def test_preserves_regular_punctuation(self):
+        """Test that regular punctuation and symbols are preserved."""
+        assert sanitize_for_logging("Hello, World!") == "Hello, World!"
+        assert sanitize_for_logging("Cost: $100 (20% off)") == "Cost: $100 (20% off)"
+        assert sanitize_for_logging("Email: test@example.com") == "Email: test@example.com"
+
+    def test_removes_unicode_line_separator(self):
+        """Test that Unicode LINE SEPARATOR (U+2028) is removed."""
+        assert sanitize_for_logging("Hello\u2028World") == "HelloWorld"
+        assert sanitize_for_logging("\u2028Starting") == "Starting"
+        assert sanitize_for_logging("Ending\u2028") == "Ending"
+        assert sanitize_for_logging("Line1\u2028Line2\u2028Line3") == "Line1Line2Line3"
+
+    def test_removes_unicode_paragraph_separator(self):
+        """Test that Unicode PARAGRAPH SEPARATOR (U+2029) is removed."""
+        assert sanitize_for_logging("Para1\u2029Para2") == "Para1Para2"
+        assert sanitize_for_logging("\u2029Starting") == "Starting"
+        assert sanitize_for_logging("Ending\u2029") == "Ending"
+        assert sanitize_for_logging("P1\u2029P2\u2029P3") == "P1P2P3"
+
+    def test_removes_both_unicode_separators(self):
+        """Test that both Unicode separators are removed together."""
+        assert sanitize_for_logging("Text\u2028with\u2029separators") == "Textwithseparators"
+        assert sanitize_for_logging("\u2028\u2029Mixed") == "Mixed"
+        assert sanitize_for_logging("A\u2028B\u2029C\u2028D") == "ABCD"
+
+    def test_unicode_separators_with_regular_unicode(self):
+        """Test Unicode separators mixed with regular Unicode characters."""
+        assert sanitize_for_logging("Hello\u2028世界") == "Hello世界"
+        assert sanitize_for_logging("Café\u2029☕") == "Café☕"
+        assert sanitize_for_logging("Test\u2028データ\u2029More") == "TestデータMore"
+
+    def test_unicode_separator_log_injection(self):
+        """Test that Unicode separators can't be used for log injection."""
+        malicious_input = "user@example.com\u2028[ERROR] Fake error message\u2029[INFO] Fake info"
+        sanitized = sanitize_for_logging(malicious_input)
+        assert "\u2028" not in sanitized
+        assert "\u2029" not in sanitized
+        assert sanitized == "user@example.com[ERROR] Fake error message[INFO] Fake info"
+
+    def test_multiple_consecutive_unicode_separators(self):
+        """Test multiple consecutive Unicode separators are all removed."""
+        assert sanitize_for_logging("Text\u2028\u2028\u2028More") == "TextMore"
+        assert sanitize_for_logging("Text\u2029\u2029\u2029More") == "TextMore"
+        assert sanitize_for_logging("\u2028\u2029\u2028\u2029Data") == "Data"
+
+    def test_unicode_separators_with_ascii_control_chars(self):
+        """Test Unicode separators combined with ASCII control characters."""
+        assert sanitize_for_logging("Test\n\u2028\rData\u2029\tEnd") == "TestDataEnd"
+        assert sanitize_for_logging("\x00\u2028Text\u2029\x1b[31m") == "Text[31m"
+
+    def test_complex_unicode_injection_scenario(self):
+        """Test complex scenario with Unicode separators in structured log attempt."""
+        attack = "Normal text\u2028[2025-11-08 10:00:00] CRITICAL: Injected message\u2029admin logged in"
+        sanitized = sanitize_for_logging(attack)
+        assert "\u2028" not in sanitized
+        assert "\u2029" not in sanitized
+        assert "\n" not in sanitized
+        assert sanitized == "Normal text[2025-11-08 10:00:00] CRITICAL: Injected messageadmin logged in"
+
+    def test_unicode_separators_do_not_affect_other_unicode(self):
+        """Test that removing Unicode separators doesn't affect other Unicode characters."""
+        text_with_emoji = "Hello\u2028😀\u2029World🌍"
+        assert sanitize_for_logging(text_with_emoji) == "Hello😀World🌍"
+
+        text_with_chars = "Test\u2028中文\u2029العربية\u2028Ελληνικά"
+        assert sanitize_for_logging(text_with_chars) == "Test中文العربيةΕλληνικά"

atlas/tests/test_docker_env_sync.py

@@ -0,0 +1,202 @@
+"""Test to ensure docker-compose.yml environment variables stay in sync with .env.example.
+
+This test ensures that the environment variables set in docker-compose.yml for the atlas-ui
+service match those defined in .env.example, with appropriate exceptions for Docker-specific
+configurations.
+"""
+
+import re
+from pathlib import Path
+
+
+def parse_env_example(env_file_path: Path) -> dict[str, str]:
+    """Parse .env.example and extract all environment variables.
+
+    Args:
+        env_file_path: Path to the .env.example file
+
+    Returns:
+        Dictionary of environment variable names to values
+    """
+    env_vars = {}
+    with open(env_file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if line and not line.startswith('#'):
+                match = re.match(r'^([A-Z_][A-Z0-9_]*)=(.*)$', line)
+                if match:
+                    key, value = match.groups()
+                    env_vars[key] = value
+    return env_vars
+
+
+def parse_docker_compose_env(docker_compose_path: Path) -> dict[str, str]:
+    """Parse docker-compose.yml and extract environment variables for atlas-ui service.
+
+    Args:
+        docker_compose_path: Path to the docker-compose.yml file
+
+    Returns:
+        Dictionary of environment variable names to values
+    """
+    docker_env_vars = {}
+    with open(docker_compose_path, 'r', encoding='utf-8') as f:
+        in_atlas_ui_service = False
+        in_environment_section = False
+
+        for line in f:
+            # Detect when we enter the atlas-ui service block
+            if 'atlas-ui:' in line:
+                in_atlas_ui_service = True
+                in_environment_section = False
+                continue
+
+            # Detect when we enter another service block (exits atlas-ui)
+            stripped = line.strip()
+            if in_atlas_ui_service and line and stripped and not line[0].isspace() and ':' in line:
+                # We've reached a new top-level section
+                in_atlas_ui_service = False
+                in_environment_section = False
+                continue
+
+            # Check if we're entering the environment section within atlas-ui
+            if in_atlas_ui_service and 'environment:' in line:
+                in_environment_section = True
+                continue
+
+            # Check if we've exited the environment section (e.g., volumes:, depends_on:)
+            if in_environment_section and stripped and not stripped.startswith('-') and not stripped.startswith('#'):
+                if ':' in line and not stripped.startswith('- '):
+                    # We've reached a new subsection (like volumes:)
+                    in_environment_section = False
+                    continue
+
+            # Parse environment variables
+            if in_environment_section and stripped.startswith('- '):
+                # Extract env var, handling quoted values
+                env_line = stripped[2:]  # Remove "- "
+
+                # Handle quoted environment variables
+                if env_line.startswith('"'):
+                    # Find the closing quote
+                    end_quote = env_line.find('"', 1)
+                    if end_quote != -1:
+                        env_line = env_line[1:end_quote]
+
+                match = re.match(r'^([A-Z_][A-Z0-9_]*)=(.*)$', env_line)
+                if match:
+                    key = match.group(1)
+                    value = match.group(2).split('#')[0].strip()  # Remove inline comments
+                    docker_env_vars[key] = value
+
+    return docker_env_vars
+
+
+def test_docker_compose_has_required_env_vars():
+    """Test that docker-compose.yml includes all required environment variables from .env.example.
+
+    This test ensures that Docker deployments have access to the same configuration
+    options as local development environments.
+    """
+    # Get paths to the files
+    repo_root = Path(__file__).parent.parent.parent
+    env_example_path = repo_root / '.env.example'
+    docker_compose_path = repo_root / 'docker-compose.yml'
+
+    # Parse both files
+    env_example_vars = parse_env_example(env_example_path)
+    docker_compose_vars = parse_docker_compose_env(docker_compose_path)
+
+    # Define variables that are intentionally different between .env.example and docker-compose.yml
+    # These have valid Docker-specific reasons to be different or omitted
+    docker_specific_exceptions = {
+        'USE_MOCK_S3',  # Docker uses real MinIO, not mock S3
+        'VITE_APP_NAME',  # Build-time arg, not runtime env var in docker-compose
+        'VITE_FEATURE_POWERED_BY_ATLAS',  # Build-time arg, not runtime env var in docker-compose
+        # Note: The following are in .env.example as commented out, not as active vars,
+        # so they won't appear in env_example_vars and don't need to be listed here:
+        # - ATLAS_HOST (Docker-specific, set to 0.0.0.0 for container networking)
+        # - Various MCP/proxy secret headers that are commented out in .env.example
+    }
+
+    # Find variables in .env.example but not in docker-compose.yml
+    missing_vars = set(env_example_vars.keys()) - set(docker_compose_vars.keys()) - docker_specific_exceptions
+
+    # Assert that no required variables are missing
+    if missing_vars:
+        missing_list = sorted(missing_vars)
+        error_msg = (
+            f"docker-compose.yml is missing {len(missing_vars)} environment variable(s) "
+            f"that are defined in .env.example:\n"
+            f"{', '.join(missing_list)}\n\n"
+            f"Please add these to the 'environment:' section of the 'atlas-ui' service "
+            f"in docker-compose.yml."
+        )
+        raise AssertionError(error_msg)
+
+    # Verify that key feature flags are present (as mentioned in the issue)
+    key_feature_flags = [
+        'FEATURE_MARKETPLACE_ENABLED',
+        'FEATURE_TOOLS_ENABLED',
+        'FEATURE_FILES_PANEL_ENABLED',
+        'FEATURE_RAG_ENABLED',
+    ]
+
+    for flag in key_feature_flags:
+        assert flag in docker_compose_vars, (
+            f"Key feature flag '{flag}' is missing from docker-compose.yml"
+        )
+
+
+def test_docker_compose_env_var_values_reasonable():
+    """Test that environment variable values in docker-compose.yml are reasonable.
+
+    This is a sanity check to ensure values aren't accidentally corrupted.
+    """
+    repo_root = Path(__file__).parent.parent.parent
+    docker_compose_path = repo_root / 'docker-compose.yml'
+
+    docker_compose_vars = parse_docker_compose_env(docker_compose_path)
+
+    # Check that boolean feature flags have boolean-like values
+    feature_flags = [k for k in docker_compose_vars.keys() if k.startswith('FEATURE_')]
+    for flag in feature_flags:
+        value = docker_compose_vars[flag].lower()
+        assert value in ['true', 'false'], (
+            f"Feature flag '{flag}' has non-boolean value: '{docker_compose_vars[flag]}'"
+        )
+
+    # Check that numeric values are numeric
+    numeric_vars = ['PORT', 'AGENT_MAX_STEPS']
+    for var in numeric_vars:
+        if var in docker_compose_vars:
+            value = docker_compose_vars[var]
+            assert value.isdigit(), (
+                f"Numeric variable '{var}' has non-numeric value: '{value}'"
+            )
+
+
+def test_docker_specific_vars_present():
+    """Test that Docker-specific environment variables are correctly set.
+
+    These variables have Docker-specific values that differ from .env.example.
+    """
+    repo_root = Path(__file__).parent.parent.parent
+    docker_compose_path = repo_root / 'docker-compose.yml'
+
+    docker_compose_vars = parse_docker_compose_env(docker_compose_path)
+
+    # ATLAS_HOST should be 0.0.0.0 for Docker (allows external connections)
+    assert 'ATLAS_HOST' in docker_compose_vars, (
+        "ATLAS_HOST is required in docker-compose.yml for container networking"
+    )
+    assert docker_compose_vars['ATLAS_HOST'] == '0.0.0.0', (
+        "ATLAS_HOST should be 0.0.0.0 in Docker for external access"
+    )
+
+    # MinIO/S3 configuration should be present for Docker
+    s3_vars = ['S3_ENDPOINT', 'S3_BUCKET_NAME', 'S3_ACCESS_KEY', 'S3_SECRET_KEY']
+    for var in s3_vars:
+        assert var in docker_compose_vars, (
+            f"S3 configuration variable '{var}' is required in docker-compose.yml for MinIO integration"
+        )