oraios--serena/test/solidlsp/go/test_go_basic.py

import os
from pathlib import Path

import pytest

from serena.symbol import LanguageServerSymbol
from solidlsp import SolidLanguageServer
from solidlsp.ls_config import Language
from solidlsp.ls_utils import SymbolUtils
from test.conftest import find_identifier_position, get_repo_path, language_has_verified_implementation_support
from test.solidlsp.conftest import format_symbol_for_assert, has_malformed_name, request_all_symbols


@pytest.mark.go
class TestGoLanguageServer:
    @pytest.mark.parametrize("language_server", [Language.GO], indirect=True)
    def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
        symbols = language_server.request_full_symbol_tree()
        assert SymbolUtils.symbol_tree_contains_name(symbols, "main"), "main function not found in symbol tree"
        assert SymbolUtils.symbol_tree_contains_name(symbols, "Helper"), "Helper function not found in symbol tree"
        assert SymbolUtils.symbol_tree_contains_name(symbols, "DemoStruct"), "DemoStruct not found in symbol tree"

    @pytest.mark.parametrize("language_server", [Language.GO], indirect=True)
    def test_find_symbol_matches_go_method_by_bare_name(self, language_server: SolidLanguageServer) -> None:
        symbols = language_server.request_full_symbol_tree(within_relative_path="main.go")

        assert SymbolUtils.symbol_tree_contains_name(symbols, "Value"), "Expected Go method name to be normalized to bare name"
        assert not SymbolUtils.symbol_tree_contains_name(symbols, "(*DemoStruct).Value"), (
            "Expected receiver-qualified Go method name to be normalized away"
        )

        bare_name_matches = [match for root in symbols for match in LanguageServerSymbol(root).find("Value")]

        assert bare_name_matches, "Expected a Go method to match by bare name"
        assert all(match.name == "Value" for match in bare_name_matches)

    @pytest.mark.parametrize("language_server", [Language.GO], indirect=True)
    def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
        file_path = os.path.join("main.go")
        symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()
        helper_symbol = None
        for sym in symbols[0]:
            if sym.get("name") == "Helper":
                helper_symbol = sym
                break
        assert helper_symbol is not None, "Could not find 'Helper' function symbol in main.go"
        sel_start = helper_symbol["selectionRange"]["start"]
        refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"])
        assert any("main.go" in ref.get("uri", "") for ref in refs), "Expected at least one reference result to point at main.go"

    if language_has_verified_implementation_support(Language.GO):

        @pytest.mark.parametrize("language_server", [Language.GO], indirect=True)
        def test_find_implementations(self, language_server: SolidLanguageServer) -> None:
            repo_path = get_repo_path(Language.GO)
            pos = find_identifier_position(repo_path / "main.go", "FormatGreeting")
            assert pos is not None, "Could not find Greeter.FormatGreeting in fixture"

            implementations = language_server.request_implementation("main.go", *pos)
            assert implementations, "Expected at least one implementation of Greeter.FormatGreeting"
            assert any("main.go" in implementation.get("relativePath", "") for implementation in implementations), (
                f"Expected ConsoleGreeter.FormatGreeting in implementations, got: {implementations}"
            )

        @pytest.mark.parametrize("language_server", [Language.GO], indirect=True)
        def test_request_implementing_symbols(self, language_server: SolidLanguageServer) -> None:
            repo_path = get_repo_path(Language.GO)
            pos = find_identifier_position(repo_path / "main.go", "FormatGreeting")
            assert pos is not None, "Could not find Greeter.FormatGreeting in fixture"

            implementing_symbols = language_server.request_implementing_symbols("main.go", *pos)
            assert implementing_symbols, "Expected implementing symbols for Greeter.FormatGreeting"
            assert any(
                symbol.get("name") == "FormatGreeting" and "main.go" in symbol["location"].get("relativePath", "")
                for symbol in implementing_symbols
            ), f"Expected FormatGreeting symbol, got: {implementing_symbols}"


def _filter_symbols_by_name_in_repo(symbols: list | None, target_name: str, repo_name: str = "test_repo") -> list:
    """Filter workspace symbols to exact name matches in the test repo."""
    if symbols is None:
        return []
    return [s for s in symbols if s.get("name") == target_name and repo_name in s.get("location", {}).get("uri", "")]


@pytest.mark.go
class TestGoBuildTags:
    """Tests for Go build tag/constraint support."""

    def _copy_go_fixture(self, tmp_path: Path) -> Path:
        """Copy Go fixture repo into tmp_path."""
        import shutil

        from test.conftest import get_repo_path

        fixture_path = get_repo_path(Language.GO)
        target_path = tmp_path / "test_repo"

        shutil.copytree(fixture_path, target_path)
        return target_path

    def test_default_context_contains_xnotfoo(self, tmp_path: Path) -> None:
        """Default build context should contain XNotFoo and not XFoo."""
        from test.conftest import start_ls_context

        repo_path = self._copy_go_fixture(tmp_path)

        with start_ls_context(Language.GO, repo_path=str(repo_path), solidlsp_dir=tmp_path) as ls:
            xnotfoo_symbols = ls.request_workspace_symbol("XNotFoo")
            xfoo_symbols = ls.request_workspace_symbol("XFoo")

            xnotfoo_matches = _filter_symbols_by_name_in_repo(xnotfoo_symbols, "XNotFoo")
            xfoo_matches = _filter_symbols_by_name_in_repo(xfoo_symbols, "XFoo")

            assert len(xnotfoo_matches) > 0, "Default context should contain XNotFoo"
            assert len(xfoo_matches) == 0, "Default context should NOT contain XFoo"

    def test_foo_context_contains_xfoo(self, tmp_path: Path) -> None:
        """Build context with -tags=foo should contain XFoo and not XNotFoo."""
        from test.conftest import start_ls_context

        repo_path = self._copy_go_fixture(tmp_path)

        ls_settings = {
            Language.GO: {
                "gopls_settings": {
                    "buildFlags": ["-tags=foo"],
                },
            },
        }

        with start_ls_context(Language.GO, repo_path=str(repo_path), ls_specific_settings=ls_settings, solidlsp_dir=tmp_path) as ls:
            xfoo_symbols = ls.request_workspace_symbol("XFoo")
            xnotfoo_symbols = ls.request_workspace_symbol("XNotFoo")

            xfoo_matches = _filter_symbols_by_name_in_repo(xfoo_symbols, "XFoo")
            xnotfoo_matches = _filter_symbols_by_name_in_repo(xnotfoo_symbols, "XNotFoo")

            assert len(xfoo_matches) > 0, "Foo context should contain XFoo"
            assert len(xnotfoo_matches) == 0, "Foo context should NOT contain XNotFoo"

    def test_disk_cache_is_invalidated_on_build_context_switch(self, tmp_path: Path) -> None:
        """Go build context switches must not reuse persisted SolidLSP document-symbol caches."""
        import pickle

        from test.conftest import start_ls_context

        repo_path = self._copy_go_fixture(tmp_path)

        ls_settings_foo = {
            Language.GO: {
                "gopls_settings": {
                    "buildFlags": ["-tags=foo"],
                },
            },
        }

        main_go = os.path.join("main.go")

        def _assert_caches_loaded_and_clean(ls: SolidLanguageServer) -> None:
            # White-box assertions: SolidLanguageServer currently has no public API to verify that
            # caches were loaded from disk vs created lazily on first request.
            assert ls._raw_document_symbols_cache, "Expected raw document-symbol cache to load from disk"
            assert ls._document_symbols_cache, "Expected document-symbol cache to load from disk"
            assert not ls._raw_document_symbols_cache_is_modified
            assert not ls._document_symbols_cache_is_modified

        def _assert_caches_empty(ls: SolidLanguageServer) -> None:
            assert ls._raw_document_symbols_cache == {}
            assert ls._document_symbols_cache == {}

        def _assert_caches_modified(ls: SolidLanguageServer) -> None:
            assert ls._raw_document_symbols_cache_is_modified
            assert ls._document_symbols_cache_is_modified

        # Run 1 (default context): populate caches and persist them to disk.
        with start_ls_context(Language.GO, repo_path=str(repo_path), solidlsp_dir=tmp_path) as ls_default:
            _ = ls_default.request_document_symbols(main_go)

            default_raw_cache_version = ls_default._raw_document_symbols_cache_version()
            default_doc_cache_version = ls_default._document_symbols_cache_version()

            ls_default.save_cache()
            cache_dir = ls_default.cache_dir

            cache_files = [p for p in cache_dir.rglob("*") if p.is_file()]
            assert cache_files, f"Expected SolidLSP to create cache artifacts under {cache_dir}"

            versioned_cache_files: list[tuple[Path, object]] = []
            for p in cache_files:
                try:
                    with p.open("rb") as f:
                        data = pickle.load(f)
                except Exception:
                    continue
                if isinstance(data, dict) and "__cache_version" in data:
                    versioned_cache_files.append((p, data["__cache_version"]))

            assert versioned_cache_files, f"Expected at least one SolidLSP cache file with a __cache_version under {cache_dir}"
            saved_versions = {v for _, v in versioned_cache_files}
            assert default_raw_cache_version in saved_versions or default_doc_cache_version in saved_versions, (
                "Expected at least one persisted cache to match the default-context cache version"
            )

        # Run 2 (default context again): prove that persisted caches are actually loaded and used.
        with start_ls_context(Language.GO, repo_path=str(repo_path), solidlsp_dir=tmp_path) as ls_default_again:
            assert ls_default_again.cache_dir == cache_dir

            _assert_caches_loaded_and_clean(ls_default_again)

            _ = ls_default_again.request_document_symbols(main_go)

            # A cache hit should not mark caches as modified.
            assert not ls_default_again._raw_document_symbols_cache_is_modified
            assert not ls_default_again._document_symbols_cache_is_modified

        # Run 3 (foo context): the same on-disk cache directory exists, but MUST be treated as stale.
        with start_ls_context(
            Language.GO,
            repo_path=str(repo_path),
            ls_specific_settings=ls_settings_foo,
            solidlsp_dir=tmp_path,
        ) as ls_foo:
            assert ls_foo.cache_dir == cache_dir

            foo_raw_cache_version = ls_foo._raw_document_symbols_cache_version()
            foo_doc_cache_version = ls_foo._document_symbols_cache_version()

            assert foo_raw_cache_version != default_raw_cache_version
            assert foo_doc_cache_version != default_doc_cache_version

            # Different build context => persisted caches must not be loaded.
            _assert_caches_empty(ls_foo)

            _ = ls_foo.request_document_symbols(main_go)

            # A cache miss should repopulate and mark caches modified.
            _assert_caches_modified(ls_foo)

    @pytest.mark.parametrize("language_server", [Language.GO], 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 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,
            )