From e48031ea73f759a2df1b07b07fa690ebbc012241 Mon Sep 17 00:00:00 2001 From: Michael Panchenko Date: Mon, 28 Apr 2025 15:34:29 +0200 Subject: [PATCH] Tests for TS and Go, general improvements in tests --- .vscode/settings.json | 4 +- src/multilspy/lsp_protocol_handler/server.py | 3 +- test/conftest.py | 14 +++- test/multilspy/go/test_go_basic.py | 32 +++++++++ test/multilspy/java/test_java_basic.py | 48 ++++--------- test/multilspy/python/test_python_basic.py | 12 ++-- .../multilspy/python/test_symbol_retrieval.py | 46 ++++++------ test/multilspy/rust/test_rust_basic.py | 71 +++++-------------- .../typescript/test_typescript_basic.py | 32 +++++++++ test/resources/repos/go/test_repo/main.go | 20 ++++++ .../repos/typescript/test_repo/index.ts | 16 +++++ 11 files changed, 178 insertions(+), 120 deletions(-) create mode 100644 test/multilspy/go/test_go_basic.py create mode 100644 test/multilspy/typescript/test_typescript_basic.py create mode 100644 test/resources/repos/go/test_repo/main.go create mode 100644 test/resources/repos/typescript/test_repo/index.ts diff --git a/.vscode/settings.json b/.vscode/settings.json index 3f32d63..258e3b5 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -10,5 +10,7 @@ "pixi", "sensai", "vibing" - ] + ], + "basedpyright.disableLanguageServices": true, + "python.languageServer": "None" } \ No newline at end of file diff --git a/src/multilspy/lsp_protocol_handler/server.py b/src/multilspy/lsp_protocol_handler/server.py index b9dd0de..81a9dc4 100644 --- a/src/multilspy/lsp_protocol_handler/server.py +++ b/src/multilspy/lsp_protocol_handler/server.py @@ -38,6 +38,7 @@ from typing import Any, Dict, List, Optional, Union from .lsp_requests import LspNotification, LspRequest from .lsp_types import ErrorCodes +from ..multilspy_exceptions import MultilspyException StringDict = Dict[str, Any] PayloadLike = Union[List[StringDict], StringDict, None] @@ -481,7 +482,7 @@ class LanguageServerHandler: await self._send_payload(make_request(method, request_id, params)) await request.cv.wait() if isinstance(request.error, Error): - raise request.error + raise MultilspyException(f"Could not process request {method} with params:\n{params}.\n Language server error: {request.error}") from request.error return request.result def _send_payload_sync(self, payload: StringDict) -> None: diff --git a/test/conftest.py b/test/conftest.py index 0c6321d..afac89f 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -5,6 +5,7 @@ import pytest from multilspy.language_server import SyncLanguageServer from multilspy.multilspy_config import Language, MultilspyConfig from multilspy.multilspy_logger import MultilspyLogger +from multilspy.multilspy_types import UnifiedSymbolInformation @pytest.fixture(scope="session") @@ -59,7 +60,7 @@ def language_server(request: LanguageParamRequest): Example: ``` @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_python_server(language_server): + def test_python_server(language_server: SyncLanguageServer) -> None: # Use the Python language server pass ``` @@ -67,7 +68,7 @@ def language_server(request: LanguageParamRequest): You can also test multiple languages in a single test: ``` @pytest.mark.parametrize("language_server", [Language.PYTHON, Language.TYPESCRIPT], indirect=True) - def test_multiple_languages(language_server): + def test_multiple_languages(language_server: SyncLanguageServer) -> None: # This test will run once for each language pass ``` @@ -83,3 +84,12 @@ def language_server(request: LanguageParamRequest): yield server finally: server.stop() + + +def symbol_tree_contains_name(roots: list[UnifiedSymbolInformation], name: str) -> bool: + for symbol in roots: + if symbol["name"] == name: + return True + if symbol_tree_contains_name(symbol["children"], name): + return True + return False diff --git a/test/multilspy/go/test_go_basic.py b/test/multilspy/go/test_go_basic.py new file mode 100644 index 0000000..551d92a --- /dev/null +++ b/test/multilspy/go/test_go_basic.py @@ -0,0 +1,32 @@ +import os + +import pytest +from conftest import symbol_tree_contains_name + +from multilspy import SyncLanguageServer +from multilspy.multilspy_config import Language + + +class TestGoLanguageServer: + @pytest.mark.parametrize("language_server", [Language.GO], indirect=True) + def test_find_symbol(self, language_server: SyncLanguageServer) -> None: + symbols = language_server.request_full_symbol_tree() + assert symbol_tree_contains_name(symbols, "main"), "main function not found in symbol tree" + assert symbol_tree_contains_name(symbols, "Helper"), "Helper function not found in symbol tree" + assert symbol_tree_contains_name(symbols, "DemoStruct"), "DemoStruct not found in symbol tree" + + @pytest.mark.parametrize("language_server", [Language.GO], indirect=True) + def test_find_referencing_symbols(self, language_server: SyncLanguageServer) -> None: + file_path = os.path.join("main.go") + symbols = language_server.request_document_symbols(file_path) + 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("relativePath", "") for ref in refs + ), "main.go should reference Helper (tried all positions in selectionRange)" diff --git a/test/multilspy/java/test_java_basic.py b/test/multilspy/java/test_java_basic.py index d66753f..9b9cf92 100644 --- a/test/multilspy/java/test_java_basic.py +++ b/test/multilspy/java/test_java_basic.py @@ -1,30 +1,22 @@ import os import pytest +from conftest import symbol_tree_contains_name +from multilspy import SyncLanguageServer from multilspy.multilspy_config import Language -def find_symbol_recursive(symbols, name): - for symbol in symbols: - if symbol.get("name") == name: - return True - if symbol.get("children"): - if find_symbol_recursive(symbol["children"], name): - return True - return False - - class TestJavaLanguageServer: @pytest.mark.parametrize("language_server", [Language.JAVA], indirect=True) - def test_find_symbol(self, language_server): + def test_find_symbol(self, language_server: SyncLanguageServer) -> None: symbols = language_server.request_full_symbol_tree() - assert find_symbol_recursive(symbols, "Main"), "Main class not found in symbol tree" - assert find_symbol_recursive(symbols, "Utils"), "Utils class not found in symbol tree" - assert find_symbol_recursive(symbols, "Model"), "Model class not found in symbol tree" + assert symbol_tree_contains_name(symbols, "Main"), "Main class not found in symbol tree" + assert symbol_tree_contains_name(symbols, "Utils"), "Utils class not found in symbol tree" + assert symbol_tree_contains_name(symbols, "Model"), "Model class not found in symbol tree" @pytest.mark.parametrize("language_server", [Language.JAVA], indirect=True) - def test_find_referencing_symbols(self, language_server): + def test_find_referencing_symbols(self, language_server: SyncLanguageServer) -> None: # Use correct Maven/Java file paths file_path = os.path.join("src", "main", "java", "test_repo", "Utils.java") refs = language_server.request_references(file_path, 4, 20) @@ -42,26 +34,16 @@ class TestJavaLanguageServer: # Use selectionRange if present, otherwise fall back to range if "selectionRange" in model_symbol: sel_start = model_symbol["selectionRange"]["start"] - sel_end = model_symbol["selectionRange"]["end"] else: sel_start = model_symbol["range"]["start"] - sel_end = model_symbol["range"]["end"] - found = False - if sel_start["line"] == sel_end["line"]: - for col in range(sel_start["character"], sel_end["character"] + 1): - refs = language_server.request_references(file_path, sel_start["line"], col) - if any("Main.java" in ref.get("relativePath", "") for ref in refs): - found = True - else: - refs_start = language_server.request_references(file_path, sel_start["line"], sel_start["character"]) - refs_end = language_server.request_references(file_path, sel_end["line"], sel_end["character"]) - if any("Main.java" in ref.get("relativePath", "") for ref in refs_start + refs_end): - found = True - assert found, "Main should reference Model (tried all positions in selectionRange)" + refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"]) + assert any( + "Main.java" in ref.get("relativePath", "") for ref in refs + ), "Main should reference Model (tried all positions in selectionRange)" @pytest.mark.parametrize("language_server", [Language.JAVA], indirect=True) - def test_overview_methods(self, language_server): + def test_overview_methods(self, language_server: SyncLanguageServer) -> None: symbols = language_server.request_full_symbol_tree() - assert find_symbol_recursive(symbols, "Main"), "Main missing from overview" - assert find_symbol_recursive(symbols, "Utils"), "Utils missing from overview" - assert find_symbol_recursive(symbols, "Model"), "Model missing from overview" + assert symbol_tree_contains_name(symbols, "Main"), "Main missing from overview" + assert symbol_tree_contains_name(symbols, "Utils"), "Utils missing from overview" + assert symbol_tree_contains_name(symbols, "Model"), "Model missing from overview" diff --git a/test/multilspy/python/test_python_basic.py b/test/multilspy/python/test_python_basic.py index ddf5036..635b19f 100644 --- a/test/multilspy/python/test_python_basic.py +++ b/test/multilspy/python/test_python_basic.py @@ -18,7 +18,7 @@ class TestLanguageServerBasics: """Test basic functionality of the language server.""" @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_references_user_class(self, language_server: SyncLanguageServer): + def test_request_references_user_class(self, language_server: SyncLanguageServer) -> None: """Test request_references on the User class.""" # Get references to the User class in models.py file_path = os.path.join("test_repo", "models.py") @@ -33,7 +33,7 @@ class TestLanguageServerBasics: assert len(references) > 1, "User class should be referenced in multiple files (using selectionRange if present)" @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_references_item_class(self, language_server: SyncLanguageServer): + def test_request_references_item_class(self, language_server: SyncLanguageServer) -> None: """Test request_references on the Item class.""" # Get references to the Item class in models.py file_path = os.path.join("test_repo", "models.py") @@ -49,7 +49,7 @@ class TestLanguageServerBasics: assert len(services_references) > 0, "At least one reference should be in services.py (using selectionRange if present)" @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_references_function_parameter(self, language_server: SyncLanguageServer): + def test_request_references_function_parameter(self, language_server: SyncLanguageServer) -> None: """Test request_references on a function parameter.""" # Get references to the id parameter in get_user method file_path = os.path.join("test_repo", "services.py") @@ -64,7 +64,7 @@ class TestLanguageServerBasics: assert len(references) > 0, "id parameter should be referenced within the method (using selectionRange if present)" @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_references_create_user_method(self, language_server: SyncLanguageServer): + def test_request_references_create_user_method(self, language_server: SyncLanguageServer) -> None: # Get references to the create_user method in UserService file_path = os.path.join("test_repo", "services.py") # Line 15 contains the create_user method definition @@ -78,7 +78,7 @@ class TestLanguageServerBasics: assert len(references) > 1, "Should get valid references for create_user (using selectionRange if present)" @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_retrieve_content_around_line(self, language_server: SyncLanguageServer): + def test_retrieve_content_around_line(self, language_server: SyncLanguageServer) -> None: """Test retrieve_content_around_line functionality with various scenarios.""" file_path = os.path.join("test_repo", "models.py") @@ -185,7 +185,7 @@ class TestLanguageServerBasics: assert line.match_type == LineType.AFTER_MATCH @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_search_files_for_pattern(self, language_server: SyncLanguageServer): + def test_search_files_for_pattern(self, language_server: SyncLanguageServer) -> None: """Test search_files_for_pattern with various patterns and glob filters.""" # Test 1: Search for class definitions across all files class_pattern = r"class\s+\w+\s*(?:\([^{]*\)|:)" diff --git a/test/multilspy/python/test_symbol_retrieval.py b/test/multilspy/python/test_symbol_retrieval.py index 700f7e6..6f7b22c 100644 --- a/test/multilspy/python/test_symbol_retrieval.py +++ b/test/multilspy/python/test_symbol_retrieval.py @@ -19,7 +19,7 @@ class TestLanguageServerSymbols: """Test the language server's symbol-related functionality.""" @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_containing_symbol_function(self, language_server: SyncLanguageServer): + def test_request_containing_symbol_function(self, language_server: SyncLanguageServer) -> None: """Test request_containing_symbol for a function.""" # Test for a position inside the create_user method file_path = os.path.join("test_repo", "services.py") @@ -34,7 +34,7 @@ class TestLanguageServerSymbols: assert containing_symbol["body"].strip().startswith("def create_user(self") @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_references_to_variables(self, language_server: SyncLanguageServer): + def test_references_to_variables(self, language_server: SyncLanguageServer) -> None: """Test request_referencing_symbols for a variable.""" file_path = os.path.join("test_repo", "variables.py") # Line 75 contains the field status that is later modified @@ -49,7 +49,7 @@ class TestLanguageServerSymbols: assert "second_dataclass" in ref_names @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_containing_symbol_class(self, language_server: SyncLanguageServer): + def test_request_containing_symbol_class(self, language_server: SyncLanguageServer) -> None: """Test request_containing_symbol for a class.""" # Test for a position inside the UserService class but outside any method file_path = os.path.join("test_repo", "services.py") @@ -62,7 +62,7 @@ class TestLanguageServerSymbols: assert containing_symbol["kind"] == SymbolKind.Class @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_containing_symbol_nested(self, language_server: SyncLanguageServer): + def test_request_containing_symbol_nested(self, language_server: SyncLanguageServer) -> None: """Test request_containing_symbol with nested scopes.""" # Test for a position inside a method which is inside a class file_path = os.path.join("test_repo", "services.py") @@ -88,7 +88,7 @@ class TestLanguageServerSymbols: assert parent_symbol["kind"] == SymbolKind.Class @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_containing_symbol_none(self, language_server: SyncLanguageServer): + def test_request_containing_symbol_none(self, language_server: SyncLanguageServer) -> None: """Test request_containing_symbol for a position with no containing symbol.""" # Test for a position outside any function/class (e.g., in imports) file_path = os.path.join("test_repo", "services.py") @@ -99,7 +99,7 @@ class TestLanguageServerSymbols: assert containing_symbol is None or containing_symbol == {} @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_referencing_symbols_function(self, language_server: SyncLanguageServer): + def test_request_referencing_symbols_function(self, language_server: SyncLanguageServer) -> None: """Test request_referencing_symbols for a function.""" # Test referencing symbols for create_user function file_path = os.path.join("test_repo", "services.py") @@ -121,7 +121,7 @@ class TestLanguageServerSymbols: assert "end" in symbol["location"]["range"] @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_referencing_symbols_class(self, language_server: SyncLanguageServer): + def test_request_referencing_symbols_class(self, language_server: SyncLanguageServer) -> None: """Test request_referencing_symbols for a class.""" # Test referencing symbols for User class file_path = os.path.join("test_repo", "models.py") @@ -140,7 +140,7 @@ class TestLanguageServerSymbols: assert len(services_references) > 0, "No referencing symbols from services.py for User (selectionRange)" @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_referencing_symbols_parameter(self, language_server: SyncLanguageServer): + def test_request_referencing_symbols_parameter(self, language_server: SyncLanguageServer) -> None: """Test request_referencing_symbols for a function parameter.""" # Test referencing symbols for id parameter in get_user file_path = os.path.join("test_repo", "services.py") @@ -154,14 +154,12 @@ class TestLanguageServerSymbols: method_refs = [ symbol for symbol in ref_symbols - if "location" in symbol - and "range" in symbol["location"] - and symbol["location"]["range"]["start"]["line"] > sel_start["line"] + if "location" in symbol and "range" in symbol["location"] and symbol["location"]["range"]["start"]["line"] > sel_start["line"] ] assert len(method_refs) > 0, "No referencing symbols within method body for get_user (selectionRange)" @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_referencing_symbols_none(self, language_server: SyncLanguageServer): + def test_request_referencing_symbols_none(self, language_server: SyncLanguageServer) -> None: """Test request_referencing_symbols for a position with no symbol.""" # For positions with no symbol, the method might throw an error or return None/empty list # We'll modify our test to handle this by using a try-except block @@ -179,7 +177,7 @@ class TestLanguageServerSymbols: # Tests for request_defining_symbol @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_defining_symbol_variable(self, language_server: SyncLanguageServer): + def test_request_defining_symbol_variable(self, language_server: SyncLanguageServer) -> None: """Test request_defining_symbol for a variable usage.""" # Test finding the definition of a symbol in the create_user method file_path = os.path.join("test_repo", "services.py") @@ -198,7 +196,7 @@ class TestLanguageServerSymbols: assert "services.py" in defining_symbol["location"]["uri"] @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_defining_symbol_imported_class(self, language_server: SyncLanguageServer): + def test_request_defining_symbol_imported_class(self, language_server: SyncLanguageServer) -> None: """Test request_defining_symbol for an imported class.""" # Test finding the definition of the 'User' class used in the UserService.create_user method file_path = os.path.join("test_repo", "services.py") @@ -210,7 +208,7 @@ class TestLanguageServerSymbols: assert defining_symbol.get("name") == "User" @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_defining_symbol_method_call(self, language_server: SyncLanguageServer): + def test_request_defining_symbol_method_call(self, language_server: SyncLanguageServer) -> None: """Test request_defining_symbol for a method call.""" # Create an example file path for a file that calls UserService.create_user examples_file_path = os.path.join("examples", "user_management.py") @@ -235,7 +233,7 @@ class TestLanguageServerSymbols: warnings.warn("Could not verify method call definition - file structure may differ from expected") @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_defining_symbol_none(self, language_server: SyncLanguageServer): + def test_request_defining_symbol_none(self, language_server: SyncLanguageServer) -> None: """Test request_defining_symbol for a position with no symbol.""" # Test for a position with no symbol (e.g., whitespace or comment) file_path = os.path.join("test_repo", "services.py") @@ -246,7 +244,7 @@ class TestLanguageServerSymbols: assert defining_symbol is None @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_containing_symbol_variable(self, language_server: SyncLanguageServer): + def test_request_containing_symbol_variable(self, language_server: SyncLanguageServer) -> None: """Test request_containing_symbol where the symbol is a variable.""" # Test for a position inside a variable definition file_path = os.path.join("test_repo", "services.py") @@ -259,7 +257,7 @@ class TestLanguageServerSymbols: assert containing_symbol["kind"] == SymbolKind.Variable @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_defining_symbol_nested_function(self, language_server: SyncLanguageServer): + def test_request_defining_symbol_nested_function(self, language_server: SyncLanguageServer) -> None: """Test request_defining_symbol for a nested function or closure.""" # Use the existing nested.py file which contains nested classes and methods file_path = os.path.join("test_repo", "nested.py") @@ -310,7 +308,7 @@ class TestLanguageServerSymbols: assert defining_symbol.get("kind") == SymbolKind.Function.value @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_symbol_methods_integration(self, language_server: SyncLanguageServer): + def test_symbol_methods_integration(self, language_server: SyncLanguageServer) -> None: """Test the integration between different symbol-related methods.""" # This test demonstrates using the various symbol methods together # by finding a symbol and then checking its definition @@ -359,7 +357,7 @@ class TestLanguageServerSymbols: warnings.warn("Could not verify container hierarchy - implementation detail") @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_symbol_tree_structure(self, language_server: SyncLanguageServer): + def test_symbol_tree_structure(self, language_server: SyncLanguageServer) -> None: """Test that the symbol tree structure is correctly built.""" # Get all symbols in the test file repo_structure = language_server.request_full_symbol_tree() @@ -387,7 +385,7 @@ class TestLanguageServerSymbols: assert user_management_roots == user_management_node["children"] @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_symbol_tree_structure_subdir(self, language_server: SyncLanguageServer): + def test_symbol_tree_structure_subdir(self, language_server: SyncLanguageServer) -> None: """Test that the symbol tree structure is correctly built.""" # Get all symbols in the test file examples_package_roots = language_server.request_full_symbol_tree(within_relative_path="examples") @@ -408,7 +406,7 @@ class TestLanguageServerSymbols: assert user_management_roots == user_management_node["children"] @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_dir_overview(self, language_server: SyncLanguageServer): + def test_request_dir_overview(self, language_server: SyncLanguageServer) -> None: """Test that request_dir_overview returns correct symbol information for files in a directory.""" # Get overview of the examples directory overview = language_server.request_dir_overview("test_repo") @@ -433,7 +431,7 @@ class TestLanguageServerSymbols: assert symbol in services_symbols @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_request_document_overview(self, language_server: SyncLanguageServer): + def test_request_document_overview(self, language_server: SyncLanguageServer) -> None: """Test that request_document_overview returns correct symbol information for a file.""" # Get overview of the user_management.py file overview = language_server.request_document_overview(os.path.join("examples", "user_management.py")) @@ -443,7 +441,7 @@ class TestLanguageServerSymbols: assert {"UserStats", "UserManager", "process_user_data", "main"}.issubset(symbol_names) @pytest.mark.parametrize("language_server", [Language.PYTHON], indirect=True) - def test_containing_symbol_of_var_is_file(self, language_server: SyncLanguageServer): + def test_containing_symbol_of_var_is_file(self, language_server: SyncLanguageServer) -> None: """Test that the containing symbol of a variable is the file itself.""" # Get the containing symbol of a variable in a file file_path = os.path.join("test_repo", "services.py") diff --git a/test/multilspy/rust/test_rust_basic.py b/test/multilspy/rust/test_rust_basic.py index 8b1d1a5..17a92f2 100644 --- a/test/multilspy/rust/test_rust_basic.py +++ b/test/multilspy/rust/test_rust_basic.py @@ -1,23 +1,15 @@ import os import pytest +from conftest import symbol_tree_contains_name +from multilspy import SyncLanguageServer from multilspy.multilspy_config import Language -def find_symbol_recursive(symbols, name): - for symbol in symbols: - if symbol.get("name") == name: - return True - if symbol.get("children"): - if find_symbol_recursive(symbol["children"], name): - return True - return False - - class TestRustLanguageServer: @pytest.mark.parametrize("language_server", [Language.RUST], indirect=True) - def test_find_references_raw(self, language_server): + def test_find_references_raw(self, language_server: SyncLanguageServer) -> None: # Directly test the request_references method for the add function file_path = os.path.join("src", "lib.rs") symbols = language_server.request_document_symbols(file_path) @@ -28,32 +20,20 @@ class TestRustLanguageServer: break assert add_symbol is not None, "Could not find 'add' function symbol in lib.rs" sel_start = add_symbol["selectionRange"]["start"] - sel_end = add_symbol["selectionRange"]["end"] - found = False - if sel_start["line"] == sel_end["line"]: - for col in range(sel_start["character"], sel_end["character"] + 1): - refs = language_server.request_references(file_path, sel_start["line"], col) - # f"Raw request_references for add in lib.rs at col {col}: {refs}") - if any("main.rs" in ref.get("relativePath", "") for ref in refs): - found = True - else: - refs_start = language_server.request_references(file_path, sel_start["line"], sel_start["character"]) - refs_end = language_server.request_references(file_path, sel_end["line"], sel_end["character"]) - # f"Raw request_references for add in lib.rs at selectionRange start: {refs_start}") - # f"Raw request_references for add in lib.rs at selectionRange end: {refs_end}") - if any("main.rs" in ref.get("relativePath", "") for ref in refs_start + refs_end): - found = True - assert found, "main.rs should reference add (raw, tried all positions in selectionRange)" + refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"]) + assert any( + "main.rs" in ref.get("relativePath", "") for ref in refs + ), "main.rs should reference add (raw, tried all positions in selectionRange)" @pytest.mark.parametrize("language_server", [Language.RUST], indirect=True) - def test_find_symbol(self, language_server): + def test_find_symbol(self, language_server: SyncLanguageServer) -> None: symbols = language_server.request_full_symbol_tree() - assert find_symbol_recursive(symbols, "main"), "main function not found in symbol tree" - assert find_symbol_recursive(symbols, "add"), "add function not found in symbol tree" + assert symbol_tree_contains_name(symbols, "main"), "main function not found in symbol tree" + assert symbol_tree_contains_name(symbols, "add"), "add function not found in symbol tree" # Add more as needed based on test_repo @pytest.mark.parametrize("language_server", [Language.RUST], indirect=True) - def test_find_referencing_symbols(self, language_server): + def test_find_referencing_symbols(self, language_server: SyncLanguageServer) -> None: # Find references to 'add' defined in lib.rs, should be referenced from main.rs file_path = os.path.join("src", "lib.rs") symbols = language_server.request_document_symbols(file_path) @@ -64,28 +44,13 @@ class TestRustLanguageServer: break assert add_symbol is not None, "Could not find 'add' function symbol in lib.rs" sel_start = add_symbol["selectionRange"]["start"] - sel_end = add_symbol["selectionRange"]["end"] - # f"add symbol selectionRange: start={sel_start}, end={sel_end}") - found = False - # Try all character positions in the selectionRange (same line, from start to end character) - if sel_start["line"] == sel_end["line"]: - for col in range(sel_start["character"], sel_end["character"] + 1): - refs = language_server.request_references(file_path, sel_start["line"], col) - # f"References for add in lib.rs at col {col} (selectionRange): {refs}") - if any("main.rs" in ref.get("relativePath", "") for ref in refs): - found = True - else: - # If the function name spans multiple lines, try start and end - refs_start = language_server.request_references(file_path, sel_start["line"], sel_start["character"]) - refs_end = language_server.request_references(file_path, sel_end["line"], sel_end["character"]) - # f"References for add in lib.rs at selectionRange start: {refs_start}") - # f"References for add in lib.rs at selectionRange end: {refs_end}") - if any("main.rs" in ref.get("relativePath", "") for ref in refs_start + refs_end): - found = True - assert found, "main.rs should reference add (tried all positions in selectionRange)" + refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"]) + assert any( + "main.rs" in ref.get("relativePath", "") for ref in refs + ), "main.rs should reference add (tried all positions in selectionRange)" @pytest.mark.parametrize("language_server", [Language.RUST], indirect=True) - def test_overview_methods(self, language_server): + def test_overview_methods(self, language_server: SyncLanguageServer) -> None: symbols = language_server.request_full_symbol_tree() - assert find_symbol_recursive(symbols, "main"), "main missing from overview" - assert find_symbol_recursive(symbols, "add"), "add missing from overview" + assert symbol_tree_contains_name(symbols, "main"), "main missing from overview" + assert symbol_tree_contains_name(symbols, "add"), "add missing from overview" diff --git a/test/multilspy/typescript/test_typescript_basic.py b/test/multilspy/typescript/test_typescript_basic.py new file mode 100644 index 0000000..5c4bd77 --- /dev/null +++ b/test/multilspy/typescript/test_typescript_basic.py @@ -0,0 +1,32 @@ +import os + +import pytest +from conftest import symbol_tree_contains_name + +from multilspy import SyncLanguageServer +from multilspy.multilspy_config import Language + + +class TestTypescriptLanguageServer: + @pytest.mark.parametrize("language_server", [Language.TYPESCRIPT], indirect=True) + def test_find_symbol(self, language_server: SyncLanguageServer) -> None: + symbols = language_server.request_full_symbol_tree() + assert symbol_tree_contains_name(symbols, "DemoClass"), "DemoClass not found in symbol tree" + assert symbol_tree_contains_name(symbols, "helperFunction"), "helperFunction not found in symbol tree" + assert symbol_tree_contains_name(symbols, "printValue"), "printValue method not found in symbol tree" + + @pytest.mark.parametrize("language_server", [Language.TYPESCRIPT], indirect=True) + def test_find_referencing_symbols(self, language_server: SyncLanguageServer) -> None: + file_path = os.path.join("index.ts") + symbols = language_server.request_document_symbols(file_path) + helper_symbol = None + for sym in symbols[0]: + if sym.get("name") == "helperFunction": + helper_symbol = sym + break + assert helper_symbol is not None, "Could not find 'helperFunction' symbol in index.ts" + sel_start = helper_symbol["selectionRange"]["start"] + refs = language_server.request_references(file_path, sel_start["line"], sel_start["character"]) + assert any( + "index.ts" in ref.get("relativePath", "") for ref in refs + ), "index.ts should reference helperFunction (tried all positions in selectionRange)" diff --git a/test/resources/repos/go/test_repo/main.go b/test/resources/repos/go/test_repo/main.go new file mode 100644 index 0000000..b38c31f --- /dev/null +++ b/test/resources/repos/go/test_repo/main.go @@ -0,0 +1,20 @@ +package main + +import "fmt" + +func main() { + fmt.Println("Hello, Go!") + Helper() +} + +func Helper() { + fmt.Println("Helper function called") +} + +type DemoStruct struct { + Field int +} + +func UsingHelper() { + Helper() +} diff --git a/test/resources/repos/typescript/test_repo/index.ts b/test/resources/repos/typescript/test_repo/index.ts new file mode 100644 index 0000000..7b8bd1d --- /dev/null +++ b/test/resources/repos/typescript/test_repo/index.ts @@ -0,0 +1,16 @@ +export class DemoClass { + value: number; + constructor(value: number) { + this.value = value; + } + printValue() { + console.log(this.value); + } +} + +export function helperFunction() { + const demo = new DemoClass(42); + demo.printValue(); +} + +helperFunction();