SousChef

"""Test core validation functions and error paths in server.py."""

import contextlib

import pytest

from souschef.server import (
    _validate_path_length,
    _validate_plan_paths,
    _validate_role_name,
)


class TestValidatePathLength:
    """Test _validate_path_length validation function."""

    def test_validate_path_length_acceptable(self) -> None:
        """Test validation with acceptable path length."""
        # Should not raise
        _validate_path_length("/valid/path", "test_path")

    def test_validate_path_length_empty_string(self) -> None:
        """Test validation with empty string."""
        # Empty string is actually valid (length 0 < limit)
        _validate_path_length("", "empty_path")

    def test_validate_path_length_exceeds_limit(self) -> None:
        """Test that exceeding path length raises ValueError."""
        # Create a path longer than the maximum (4096)
        long_path = "/" + "a" * 5000
        with pytest.raises(ValueError, match="exceeds maximum length"):
            _validate_path_length(long_path, "test_path")

    def test_validate_path_length_relative_path(self) -> None:
        """Test validation with relative path."""
        _validate_path_length("relative/path/to/file", "relative")

    def test_validate_path_length_with_spaces(self) -> None:
        """Test validation with spaces in path."""
        _validate_path_length("/path with spaces/to/file", "spaced")

    def test_validate_path_length_label_in_error(self) -> None:
        """Test that label appears in error message."""
        long_path = "/" + "a" * 5000
        with pytest.raises(ValueError) as exc_info:
            _validate_path_length(long_path, "CustomLabel")
        assert "CustomLabel" in str(exc_info.value)


class TestValidatePlanPaths:
    """Test _validate_plan_paths validation function."""

    def test_validate_plan_paths_single_path(self) -> None:
        """Test validation with a single valid path."""
        # Should not raise
        _validate_plan_paths("/path/to/plan")

    def test_validate_plan_paths_multiple_paths(self) -> None:
        """Test validation with multiple valid paths."""
        # Should not raise
        _validate_plan_paths("/path/to/plan1,/path/to/plan2")

    def test_validate_plan_paths_with_whitespace(self) -> None:
        """Test validation with whitespace in paths."""
        # Should handle whitespace correctly
        _validate_plan_paths("  /path/to/plan1  ,  /path/to/plan2  ")

    def test_validate_plan_paths_three_paths(self) -> None:
        """Test with three paths."""
        _validate_plan_paths("/path1,/path2,/path3")

    def test_validate_plan_paths_exceeds_character_limit(self) -> None:
        """Test that exceeding character limit raises ValueError."""
        # Create a string longer than the maximum (8192)
        long_path = "a" * 10000
        with pytest.raises(ValueError, match="exceed maximum length"):
            _validate_plan_paths(long_path)

    def test_validate_plan_paths_exceeds_count_limit(self) -> None:
        """Test that exceeding path count limit raises ValueError."""
        # Create 30 paths (limit is 20)
        many_paths = ",".join([f"/path/{i}" for i in range(30)])
        with pytest.raises(ValueError, match="Too many Habitat plan paths"):
            _validate_plan_paths(many_paths)

    def test_validate_plan_paths_empty_string(self) -> None:
        """Test with empty string."""
        # Empty string is valid (no paths to validate)
        _validate_plan_paths("")

    def test_validate_plan_paths_only_commas(self) -> None:
        """Test with only commas (no actual paths)."""
        # Depends on implementation - might succeed if all are stripped
        with contextlib.suppress(ValueError):
            _validate_plan_paths(",,,")


class TestValidateRoleName:
    """Test _validate_role_name validation function."""

    def test_validate_role_name_valid_underscore(self) -> None:
        """Test with valid role name containing underscore."""
        _validate_role_name("valid_role")

    def test_validate_role_name_valid_dash(self) -> None:
        """Test role name with dashes."""
        _validate_role_name("valid-role-name")

    def test_validate_role_name_valid_numbers(self) -> None:
        """Test role name with numbers."""
        _validate_role_name("role_name_123")

    def test_validate_role_name_with_spaces(self) -> None:
        """Test that spaces in role name are allowed."""
        # Spaces are actually allowed
        _validate_role_name("valid role")

    def test_validate_role_name_invalid_path_traversal(self) -> None:
        """Test that path traversal attempts raise error."""
        with pytest.raises(ValueError):
            _validate_role_name("../malicious")

    def test_validate_role_name_empty(self) -> None:
        """Test that empty role name raises error."""
        with pytest.raises(ValueError):
            _validate_role_name("")

    def test_validate_role_name_single_char(self) -> None:
        """Test with single character role name."""
        with contextlib.suppress(ValueError):
            _validate_role_name("a")

    def test_validate_role_name_long(self) -> None:
        """Test with long role name."""
        _validate_role_name("very_long_role_name_that_is_still_valid_123")


class TestValidationEdgeCases:
    """Test edge cases across validation functions."""

    def test_path_with_unicode(self) -> None:
        """Test path validation with unicode characters."""
        # Should handle unicode paths
        with contextlib.suppress(ValueError):
            _validate_path_length("/path/to/café/file", "unicode")

    def test_path_with_dots(self) -> None:
        """Test path with .. and . components."""
        _validate_path_length("/path/../other/./file", "dots")

    def test_role_name_with_leading_underscore(self) -> None:
        """Test role name starting with underscore."""
        with contextlib.suppress(ValueError):
            _validate_role_name("_private_role")

    def test_role_name_case_sensitive(self) -> None:
        """Test role names with mixed case."""
        with contextlib.suppress(ValueError):
            _validate_role_name("MyRole")


class TestValidationBoundaries:
    """Test boundary conditions."""

    def test_path_length_at_max_boundary(self) -> None:
        """Test path at maximum allowed length."""
        # Create path that's at the boundary (4096)
        max_safe_path = "/" + "a" * 4090
        with contextlib.suppress(ValueError):
            _validate_path_length(max_safe_path, "boundary")

    def test_plan_paths_at_count_boundary(self) -> None:
        """Test with exactly at the path count limit."""
        # Assuming limit is 20
        paths_at_limit = ",".join([f"/path/{i}" for i in range(20)])
        with contextlib.suppress(ValueError):
            _validate_plan_paths(paths_at_limit)

    def test_plan_paths_at_length_boundary(self) -> None:
        """Test with plan paths at character length boundary."""
        # Create paths near 8192 character limit
        paths_at_limit = "a" * 8100
        with pytest.raises(ValueError):
            _validate_plan_paths(paths_at_limit)

    def test_role_name_max_length(self) -> None:
        """Test role name at maximum reasonable length."""
        long_role = "a" * 255  # Common max identifier length
        with contextlib.suppress(ValueError):
            _validate_role_name(long_role)