oraios--serena/test/solidlsp/pascal/test_pascal_basic.py

"""
Basic integration tests for the Pascal language server functionality.

These tests validate the functionality of the language server APIs
like request_document_symbols using the Pascal test repository.

Uses genericptr/pascal-language-server which returns SymbolInformation[] format:
- Returns classes, structs, enums, typedefs, functions/procedures
- Uses correct SymbolKind values: Class=5, Function=12, Method=6, Struct=23
- Method names don't include parent class prefix; uses containerName instead
"""

import shutil

import pytest

from solidlsp import SolidLanguageServer
from solidlsp.ls_config import Language
from solidlsp.ls_types import SymbolKind
from test.conftest import is_ci, language_tests_enabled
from test.solidlsp.conftest import format_symbol_for_assert, has_malformed_name, request_all_symbols

pytestmark = [
    pytest.mark.pascal,
    pytest.mark.skipif(not language_tests_enabled(Language.PASCAL), reason="Pascal tests are disabled (pasls/fpc not available)"),
]


@pytest.mark.pascal
@pytest.mark.skipif(shutil.which("fpc") is None and not is_ci, reason="Free Pascal compiler is not available")
class TestPascalLanguageServerBasics:
    """Test basic functionality of the Pascal language server."""

    @pytest.mark.parametrize("language_server", [Language.PASCAL], indirect=True)
    def test_pascal_language_server_initialization(self, language_server: SolidLanguageServer) -> None:
        """Test that Pascal language server can be initialized successfully."""
        assert language_server is not None
        assert language_server.language == Language.PASCAL

    @pytest.mark.parametrize("language_server", [Language.PASCAL], indirect=True)
    def test_pascal_request_document_symbols(self, language_server: SolidLanguageServer) -> None:
        """Test request_document_symbols for Pascal files.

        genericptr pasls returns proper SymbolKind values:
        - Standalone functions: kind=12 (Function)
        - Classes: kind=5 (Class)
        """
        # Test getting symbols from main.pas
        all_symbols, _root_symbols = language_server.request_document_symbols("main.pas").get_all_symbols_and_roots()

        # Should have symbols
        assert len(all_symbols) > 0, "Should have symbols in main.pas"

        # Should detect standalone functions (SymbolKind.Function = 12)
        function_symbols = [s for s in all_symbols if s.get("kind") == SymbolKind.Function]
        function_names = [s["name"] for s in function_symbols]

        assert "CalculateSum" in function_names, "Should find CalculateSum function"
        assert "PrintMessage" in function_names, "Should find PrintMessage procedure"

        # Should detect classes (SymbolKind.Class = 5)
        class_symbols = [s for s in all_symbols if s.get("kind") == SymbolKind.Class]
        class_names = [s["name"] for s in class_symbols]

        assert "TUser" in class_names, "Should find TUser class"
        assert "TUserManager" in class_names, "Should find TUserManager class"

    @pytest.mark.parametrize("language_server", [Language.PASCAL], indirect=True)
    def test_pascal_class_methods(self, language_server: SolidLanguageServer) -> None:
        """Test detection of class methods in Pascal files.

        pasls returns class methods with SymbolKind.Method (kind 6), not Function (kind 12).
        """
        all_symbols, _root_symbols = language_server.request_document_symbols("main.pas").get_all_symbols_and_roots()

        # Get all method symbols (pasls returns class methods as SymbolKind.Method = 6)
        method_symbols = [s for s in all_symbols if s.get("kind") == SymbolKind.Method]
        method_names = [s["name"] for s in method_symbols]

        # Should detect TUser methods
        expected_tuser_methods = ["Create", "Destroy", "GetInfo", "UpdateAge"]
        for method in expected_tuser_methods:
            found = method in method_names
            assert found, f"Should find method '{method}'"

        # Should detect TUserManager methods
        expected_manager_methods = ["Create", "Destroy", "AddUser", "GetUserCount", "FindUserByName"]
        for method in expected_manager_methods:
            found = method in method_names
            assert found, f"Should find method '{method}'"

    @pytest.mark.parametrize("language_server", [Language.PASCAL], indirect=True)
    def test_pascal_helper_unit_symbols(self, language_server: SolidLanguageServer) -> None:
        """Test function detection in Helper unit."""
        # Test with lib/helper.pas
        helper_all_symbols, _helper_root_symbols = language_server.request_document_symbols("lib/helper.pas").get_all_symbols_and_roots()

        # Should have symbols
        assert len(helper_all_symbols) > 0, "Helper unit should have symbols"

        # Extract function symbols
        function_symbols = [s for s in helper_all_symbols if s.get("kind") == SymbolKind.Function]
        function_names = [s["name"] for s in function_symbols]

        # Should detect standalone functions
        expected_functions = ["GetHelperMessage", "MultiplyNumbers", "LogMessage"]
        for func_name in expected_functions:
            assert func_name in function_names, f"Should find {func_name} function in Helper unit"

        # Should also detect THelper class methods (returned as SymbolKind.Method = 6)
        method_symbols = [s for s in helper_all_symbols if s.get("kind") == SymbolKind.Method]
        method_names = [s["name"] for s in method_symbols]
        assert "FormatString" in method_names, "Should find FormatString method"
        assert "IsEven" in method_names, "Should find IsEven method"

    @pytest.mark.parametrize("language_server", [Language.PASCAL], indirect=True)
    def test_pascal_cross_file_references(self, language_server: SolidLanguageServer) -> None:
        """Test that Pascal LSP can handle cross-file references."""
        # main.pas uses Helper unit
        main_symbols, _main_roots = language_server.request_document_symbols("main.pas").get_all_symbols_and_roots()
        helper_symbols, _helper_roots = language_server.request_document_symbols("lib/helper.pas").get_all_symbols_and_roots()

        # Verify both files have symbols
        assert len(main_symbols) > 0, "main.pas should have symbols"
        assert len(helper_symbols) > 0, "helper.pas should have symbols"

        # Verify GetHelperMessage is in Helper unit
        helper_function_names = [s["name"] for s in helper_symbols if s.get("kind") == SymbolKind.Function]
        assert "GetHelperMessage" in helper_function_names, "Helper unit should export GetHelperMessage"

    @pytest.mark.parametrize("language_server", [Language.PASCAL], indirect=True)
    def test_pascal_symbol_locations(self, language_server: SolidLanguageServer) -> None:
        """Test that symbols have correct location information.

        Note: genericptr pasls returns the interface declaration location (line ~41),
        not the implementation location (line ~115).
        """
        all_symbols, _root_symbols = language_server.request_document_symbols("main.pas").get_all_symbols_and_roots()

        # Find CalculateSum function
        calc_symbols = [s for s in all_symbols if s.get("name") == "CalculateSum"]
        assert len(calc_symbols) > 0, "Should find CalculateSum"

        calc_symbol = calc_symbols[0]

        # Verify it has location information (SymbolInformation format uses location.range)
        if "location" in calc_symbol:
            location = calc_symbol["location"]
            assert "range" in location, "Location should have range"
            assert "start" in location["range"], "Range should have start"
            assert "line" in location["range"]["start"], "Start should have line"
            line = location["range"]["start"]["line"]
        else:
            # DocumentSymbol format uses range directly
            assert "range" in calc_symbol, "Symbol should have range"
            assert "start" in calc_symbol["range"], "Range should have start"
            line = calc_symbol["range"]["start"]["line"]

        # CalculateSum is declared at line 41 in main.pas (0-indexed would be 40)
        # genericptr pasls returns interface declaration location
        assert 35 <= line <= 45, f"CalculateSum should be around line 41 (interface), got {line}"

    @pytest.mark.parametrize("language_server", [Language.PASCAL], indirect=True)
    def test_pascal_namespace_symbol(self, language_server: SolidLanguageServer) -> None:
        """Test that genericptr pasls returns Interface namespace symbol."""
        all_symbols, _root_symbols = language_server.request_document_symbols("main.pas").get_all_symbols_and_roots()

        # genericptr pasls adds an "Interface" namespace symbol
        symbol_names = [s["name"] for s in all_symbols]

        # The Interface section should be represented
        # Note: This depends on pasls configuration
        assert len(all_symbols) > 0, "Should have symbols"
        # Interface namespace may or may not be present depending on pasls configuration
        _ = symbol_names  # used for potential future assertions

    @pytest.mark.parametrize("language_server", [Language.PASCAL], indirect=True)
    def test_pascal_hover_with_doc_comments(self, language_server: SolidLanguageServer) -> None:
        """Test that hover returns documentation comments.

        CalculateSum has /// style doc comments that should appear in hover.
        """
        # CalculateSum is declared at line 46 (1-indexed), so line 45 (0-indexed)
        hover = language_server.request_hover("main.pas", 45, 12)

        assert hover is not None, "Hover should return a result"

        # Extract hover content - handle both dict and object formats
        if isinstance(hover, dict):
            contents = hover.get("contents", {})
            value = contents.get("value", "") if isinstance(contents, dict) else str(contents)
        else:
            value = hover.contents.value if hasattr(hover.contents, "value") else str(hover.contents)

        # Should contain the function signature
        assert "CalculateSum" in value, f"Hover should show function name. Got: {value[:500]}"

        # Should contain the doc comment
        assert "Calculates the sum" in value, f"Hover should include doc comment. Got: {value[:500]}"

    @pytest.mark.parametrize("language_server", [Language.PASCAL], indirect=True)
    def test_bare_symbol_names(self, language_server) -> None:
        all_symbols = request_all_symbols(language_server)
        malformed_symbols = []
        for s in all_symbols:
            if s["kind"] == SymbolKind.Package:
                continue
            if has_malformed_name(s):
                malformed_symbols.append(s)
        if malformed_symbols:
            pytest.fail(
                f"Found malformed symbols: {[format_symbol_for_assert(sym) for sym in malformed_symbols]}",
                pytrace=False,
            )