From 686db18f0a977feb4b7274c79ca669f4f61089aa Mon Sep 17 00:00:00 2001 From: Alex Carney Date: Sat, 27 Jan 2024 01:01:44 +0000 Subject: [PATCH] refactor: wip end-to-end tests --- examples/servers/code_actions.py | 52 ++++++++++++++++--------------- examples/servers/code_lens.py | 49 ++++++++++++++++++++--------- examples/servers/colors.py | 11 +++++-- examples/servers/goto.py | 16 ++++++++-- examples/servers/hover.py | 10 ++++-- examples/servers/inlay_hints.py | 12 +++++-- tests/e2e/test_code_action.py | 6 ++-- tests/e2e/test_code_lens.py | 20 +++++------- tests/e2e/test_colors.py | 10 +++--- tests/e2e/test_declaration.py | 8 ++--- tests/e2e/test_definition.py | 8 ++--- tests/e2e/test_hover.py | 6 ++-- tests/e2e/test_implementation.py | 8 ++--- tests/e2e/test_inlay_hints.py | 10 +++--- tests/e2e/test_references.py | 8 ++--- tests/e2e/test_type_definition.py | 8 ++--- 16 files changed, 146 insertions(+), 96 deletions(-) diff --git a/examples/servers/code_actions.py b/examples/servers/code_actions.py index ec0382e0..dbdbb784 100644 --- a/examples/servers/code_actions.py +++ b/examples/servers/code_actions.py @@ -14,33 +14,26 @@ # See the License for the specific language governing permissions and # # limitations under the License. # ############################################################################ +import logging import re -from pygls.server import LanguageServer -from lsprotocol.types import ( - TEXT_DOCUMENT_CODE_ACTION, - CodeAction, - CodeActionKind, - CodeActionOptions, - CodeActionParams, - Position, - Range, - TextEdit, - WorkspaceEdit, -) +from lsprotocol import types + +from pygls import IS_WASM +from pygls.lsp.server import LanguageServer ADDITION = re.compile(r"^\s*(\d+)\s*\+\s*(\d+)\s*=(?=\s*$)") -server = LanguageServer("code-action-server", "v0.1") +server = LanguageServer("code-action-server", "v1") @server.feature( - TEXT_DOCUMENT_CODE_ACTION, - CodeActionOptions(code_action_kinds=[CodeActionKind.QuickFix]), + types.TEXT_DOCUMENT_CODE_ACTION, + types.CodeActionOptions(code_action_kinds=[types.CodeActionKind.QuickFix]), ) -def code_actions(params: CodeActionParams): +def code_actions(params: types.CodeActionParams): items = [] document_uri = params.text_document.uri - document = server.workspace.get_document(document_uri) + document = server.workspace.get_text_document(document_uri) start_line = params.range.start.line end_line = params.range.end.line @@ -49,21 +42,23 @@ def code_actions(params: CodeActionParams): for idx, line in enumerate(lines): match = ADDITION.match(line) if match is not None: - range_ = Range( - start=Position(line=start_line + idx, character=0), - end=Position(line=start_line + idx, character=len(line) - 1), + range_ = types.Range( + start=types.Position(line=start_line + idx, character=0), + end=types.Position(line=start_line + idx, character=len(line) - 1), ) left = int(match.group(1)) right = int(match.group(2)) answer = left + right - text_edit = TextEdit(range=range_, new_text=f"{line.strip()} {answer}!") + text_edit = types.TextEdit( + range=range_, new_text=f"{line.strip()} {answer}!" + ) - action = CodeAction( + action = types.CodeAction( title=f"Evaluate '{match.group(0)}'", - kind=CodeActionKind.QuickFix, - edit=WorkspaceEdit(changes={document_uri: [text_edit]}), + kind=types.CodeActionKind.QuickFix, + edit=types.WorkspaceEdit(changes={document_uri: [text_edit]}), ) items.append(action) @@ -71,4 +66,11 @@ def code_actions(params: CodeActionParams): if __name__ == "__main__": - server.start_io() + logging.basicConfig(level=logging.INFO, format="[%(levelname)s]: %(message)s") + + if IS_WASM: + server.start_io() + else: + import asyncio + + asyncio.run(server.start_io()) diff --git a/examples/servers/code_lens.py b/examples/servers/code_lens.py index 7a217028..2243502f 100644 --- a/examples/servers/code_lens.py +++ b/examples/servers/code_lens.py @@ -17,9 +17,11 @@ import logging import re +import attrs from lsprotocol import types -from pygls.server import LanguageServer +from pygls import IS_WASM +from pygls.lsp.server import LanguageServer ADDITION = re.compile(r"^\s*(\d+)\s*\+\s*(\d+)\s*=(?=\s*$)") server = LanguageServer("code-lens-server", "v1") @@ -74,7 +76,7 @@ def code_lens_resolve(ls: LanguageServer, item: types.CodeLens): right = item.data["right"] uri = item.data["uri"] - args = dict( + args = EvaluateSumArguments( uri=uri, left=left, right=right, @@ -84,40 +86,59 @@ def code_lens_resolve(ls: LanguageServer, item: types.CodeLens): item.command = types.Command( title=f"Evaluate {left} + {right}", command="codeLens.evaluateSum", - arguments=[args], + arguments=[ls.converter.unstructure(args)], ) return item +@attrs.define +class EvaluateSumArguments: + """Represents the arguments to be passed to ``codeLens.evaluateSum``""" + + uri: str + line: int + left: int + right: int + + @server.command("codeLens.evaluateSum") -def evaluate_sum(ls: LanguageServer, args): - logging.info("arguments: %s", args) +def evaluate_sum(ls: LanguageServer, arguments: EvaluateSumArguments): + logging.info("arguments: %s", arguments) - arguments = args[0] - document = ls.workspace.get_text_document(arguments["uri"]) - line = document.lines[arguments["line"]] + document = ls.workspace.get_text_document(arguments.uri) + line = document.lines[arguments.line] # Compute the edit that will update the document with the result. - answer = arguments["left"] + arguments["right"] + answer = arguments.left + arguments.right edit = types.TextDocumentEdit( text_document=types.OptionalVersionedTextDocumentIdentifier( - uri=arguments["uri"], version=document.version + uri=arguments.uri, version=document.version ), edits=[ types.TextEdit( new_text=f"{line.strip()} {answer}\n", range=types.Range( - start=types.Position(line=arguments["line"], character=0), - end=types.Position(line=arguments["line"] + 1, character=0), + start=types.Position(line=arguments.line, character=0), + end=types.Position(line=arguments.line + 1, character=0), ), ) ], ) # Apply the edit. - ls.apply_edit(types.WorkspaceEdit(document_changes=[edit])) + ls.workspace_apply_edit( + types.ApplyWorkspaceEditParams( + edit=types.WorkspaceEdit(document_changes=[edit]), + ) + ) if __name__ == "__main__": logging.basicConfig(level=logging.INFO, format="%(message)s") - server.start_io() + + if IS_WASM: + server.start_io() + else: + import asyncio + + asyncio.run(server.start_io()) diff --git a/examples/servers/colors.py b/examples/servers/colors.py index 2ae6a0bc..8c4630c8 100644 --- a/examples/servers/colors.py +++ b/examples/servers/colors.py @@ -19,7 +19,8 @@ from lsprotocol import types -from pygls.server import LanguageServer +from pygls import IS_WASM +from pygls.lsp.server import LanguageServer COLOR = re.compile(r"""\#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})(?!\w)""") server = LanguageServer("color-server", "v1") @@ -82,4 +83,10 @@ def color_presentation(params: types.ColorPresentationParams): if __name__ == "__main__": logging.basicConfig(level=logging.INFO, format="%(message)s") - server.start_io() + + if IS_WASM: + server.start_io() + else: + import asyncio + + asyncio.run(server.start_io()) diff --git a/examples/servers/goto.py b/examples/servers/goto.py index d2548d90..559ed668 100644 --- a/examples/servers/goto.py +++ b/examples/servers/goto.py @@ -19,7 +19,8 @@ from lsprotocol import types -from pygls.server import LanguageServer +from pygls import IS_WASM +from pygls.lsp.server import LanguageServer from pygls.workspace import TextDocument ARGUMENT = re.compile(r"(?P\w+): (?P\w+)") @@ -111,6 +112,11 @@ def goto_definition(ls: GotoLanguageServer, params: types.DefinitionParams): if index is None: return + try: + line = doc.lines[params.position.line] + except IndexError: + line = "" + word = doc.word_at_position(params.position) # Is word a type? @@ -191,4 +197,10 @@ def find_references(ls: GotoLanguageServer, params: types.ReferenceParams): if __name__ == "__main__": logging.basicConfig(level=logging.INFO, format="%(message)s") - server.start_io() + + if IS_WASM: + server.start_io() + else: + import asyncio + + asyncio.run(server.start_io()) diff --git a/examples/servers/hover.py b/examples/servers/hover.py index f7c94ee9..d7f99999 100644 --- a/examples/servers/hover.py +++ b/examples/servers/hover.py @@ -19,7 +19,8 @@ from lsprotocol import types -from pygls.server import LanguageServer +from pygls import IS_WASM +from pygls.lsp.server import LanguageServer DATE_FORMATS = [ "%H:%M:%S", @@ -75,4 +76,9 @@ def hover(params: types.HoverParams): if __name__ == "__main__": logging.basicConfig(level=logging.INFO, format="%(message)s") - server.start_io() + if IS_WASM: + server.start_io() + else: + import asyncio + + asyncio.run(server.start_io()) diff --git a/examples/servers/inlay_hints.py b/examples/servers/inlay_hints.py index e9924dd7..60a0731a 100644 --- a/examples/servers/inlay_hints.py +++ b/examples/servers/inlay_hints.py @@ -14,12 +14,14 @@ # See the License for the specific language governing permissions and # # limitations under the License. # ############################################################################ +import logging import re from typing import Optional from lsprotocol import types -from pygls.server import LanguageServer +from pygls import IS_WASM +from pygls.lsp.server import LanguageServer NUMBER = re.compile(r"\d+") COMMENT = re.compile(r"^#$") @@ -113,4 +115,10 @@ def inlay_hint_resolve(hint: types.InlayHint): if __name__ == "__main__": - server.start_io() + logging.basicConfig(level=logging.INFO, format="%(message)s") + if IS_WASM: + server.start_io() + else: + import asyncio + + asyncio.run(server.start_io()) diff --git a/tests/e2e/test_code_action.py b/tests/e2e/test_code_action.py index 7b74a4d2..6296a6e5 100644 --- a/tests/e2e/test_code_action.py +++ b/tests/e2e/test_code_action.py @@ -24,7 +24,7 @@ if typing.TYPE_CHECKING: from typing import Tuple - from pygls.lsp.client import BaseLanguageClient + from pygls.lsp.client import LanguageClient @pytest_asyncio.fixture() @@ -34,7 +34,7 @@ async def code_actions(get_client_for): async def test_code_actions( - code_actions: Tuple[BaseLanguageClient, types.InitializeResult], uri_for + code_actions: Tuple[LanguageClient, types.InitializeResult], uri_for ): """Ensure that the example code action server is working as expected.""" client, initialize_result = code_actions @@ -45,7 +45,7 @@ async def test_code_actions( test_uri = uri_for("sums.txt") assert test_uri is not None - response = await client.text_document_code_action_async( + response = await client.text_document_code_action( types.CodeActionParams( text_document=types.TextDocumentIdentifier(uri=test_uri), range=types.Range( diff --git a/tests/e2e/test_code_lens.py b/tests/e2e/test_code_lens.py index c4f40b95..90a261f5 100644 --- a/tests/e2e/test_code_lens.py +++ b/tests/e2e/test_code_lens.py @@ -25,7 +25,7 @@ if typing.TYPE_CHECKING: from typing import Tuple - from pygls.lsp.client import BaseLanguageClient + from pygls.lsp.client import LanguageClient @pytest_asyncio.fixture(scope="module") @@ -36,7 +36,7 @@ async def code_lens(get_client_for): @pytest.mark.asyncio(scope="module") async def test_code_lens( - code_lens: Tuple[BaseLanguageClient, types.InitializeResult], uri_for + code_lens: Tuple[LanguageClient, types.InitializeResult], uri_for ): """Ensure that the example code lens server is working as expected.""" client, initialize_result = code_lens @@ -45,7 +45,7 @@ async def test_code_lens( assert code_lens_options.resolve_provider is True test_uri = uri_for("sums.txt") - response = await client.text_document_code_lens_async( + response = await client.text_document_code_lens( types.CodeLensParams( text_document=types.TextDocumentIdentifier(uri=test_uri), ) @@ -77,15 +77,13 @@ async def test_code_lens( @pytest.mark.asyncio(scope="module") async def test_code_lens_resolve( - code_lens: Tuple[BaseLanguageClient, types.InitializeResult], uri_for + code_lens: Tuple[LanguageClient, types.InitializeResult], uri_for ): """Ensure that the example code lens server can resolve a code lens correctly.""" client, _ = code_lens test_uri = uri_for("sums.txt") - assert test_uri is not None - lens = types.CodeLens( range=types.Range( start=types.Position(line=0, character=0), @@ -94,7 +92,7 @@ async def test_code_lens_resolve( data=dict(left=1, right=1, uri=test_uri), ) - result = await client.code_lens_resolve_async(lens) + result = await client.code_lens_resolve(lens) # The existing fields should not be modified. assert result.range == lens.range @@ -110,7 +108,7 @@ async def test_code_lens_resolve( @pytest.mark.asyncio(scope="module") async def test_evaluate_sum( - code_lens: Tuple[BaseLanguageClient, types.InitializeResult], uri_for + code_lens: Tuple[LanguageClient, types.InitializeResult], uri_for ): """Ensure that the example code lens server can execute the ``evaluateSum`` command correctly.""" @@ -127,9 +125,7 @@ def on_edit(params: types.ApplyWorkspaceEditParams): assert provider.commands == ["codeLens.evaluateSum"] test_uri = uri_for("sums.txt") - assert test_uri is not None - - await client.workspace_execute_command_async( + await client.workspace_execute_command( types.ExecuteCommandParams( command="codeLens.evaluateSum", arguments=[dict(uri=test_uri, left=1, right=1, line=0)], @@ -144,7 +140,7 @@ def on_edit(params: types.ApplyWorkspaceEditParams): ), edits=[ types.TextEdit( - new_text="1 + 1 = 2\n", + new_text=f"1 + 1 = 2\n", range=types.Range( start=types.Position(line=0, character=0), end=types.Position(line=1, character=0), diff --git a/tests/e2e/test_colors.py b/tests/e2e/test_colors.py index ac169883..8e12f045 100644 --- a/tests/e2e/test_colors.py +++ b/tests/e2e/test_colors.py @@ -25,7 +25,7 @@ if typing.TYPE_CHECKING: from typing import Tuple - from pygls.lsp.client import BaseLanguageClient + from pygls.lsp.client import LanguageClient @pytest_asyncio.fixture(scope="module") @@ -47,7 +47,7 @@ def range_from_str(range_: str) -> types.Range: @pytest.mark.asyncio(scope="module") async def test_document_color( - colors: Tuple[BaseLanguageClient, types.InitializeResult], uri_for + colors: Tuple[LanguageClient, types.InitializeResult], uri_for ): """Ensure that the example colors server is working as expected.""" client, initialize_result = colors @@ -56,7 +56,7 @@ async def test_document_color( assert colors_options is True test_uri = uri_for("colors.txt") - response = await client.text_document_document_color_async( + response = await client.text_document_document_color( types.DocumentColorParams( text_document=types.TextDocumentIdentifier(uri=test_uri) ) @@ -104,7 +104,7 @@ async def test_document_color( @pytest.mark.asyncio(scope="module") async def test_color_presentation( - colors: Tuple[BaseLanguageClient, types.InitializeResult], uri_for + colors: Tuple[LanguageClient, types.InitializeResult], uri_for ): """Ensure that the server can convert colors to their string representation correctly.""" @@ -112,7 +112,7 @@ async def test_color_presentation( client, _ = colors test_uri = uri_for("colors.txt") - response = await client.text_document_color_presentation_async( + response = await client.text_document_color_presentation( types.ColorPresentationParams( text_document=types.TextDocumentIdentifier(uri=test_uri), color=types.Color(red=0.25, green=0.5, blue=0.75, alpha=1.0), diff --git a/tests/e2e/test_declaration.py b/tests/e2e/test_declaration.py index efb521dc..5735a845 100644 --- a/tests/e2e/test_declaration.py +++ b/tests/e2e/test_declaration.py @@ -24,7 +24,7 @@ if typing.TYPE_CHECKING: from typing import Tuple - from pygls.lsp.client import BaseLanguageClient + from pygls.lsp.client import LanguageClient @pytest_asyncio.fixture() @@ -34,7 +34,7 @@ async def goto(get_client_for): async def test_declaration( - goto: Tuple[BaseLanguageClient, types.InitializeResult], path_for, uri_for + goto: Tuple[LanguageClient, types.InitializeResult], path_for, uri_for ): """Ensure that we can implement declaration requests.""" client, initialize_result = goto @@ -56,7 +56,7 @@ async def test_declaration( ) ) - response = await client.text_document_declaration_async( + response = await client.text_document_declaration( types.DeclarationParams( text_document=types.TextDocumentIdentifier(uri=test_uri), position=types.Position(line=6, character=47), @@ -64,7 +64,7 @@ async def test_declaration( ) assert response is None - response = await client.text_document_declaration_async( + response = await client.text_document_declaration( types.DeclarationParams( text_document=types.TextDocumentIdentifier(uri=test_uri), position=types.Position(line=5, character=52), diff --git a/tests/e2e/test_definition.py b/tests/e2e/test_definition.py index cf9088ce..46ee8ade 100644 --- a/tests/e2e/test_definition.py +++ b/tests/e2e/test_definition.py @@ -24,7 +24,7 @@ if typing.TYPE_CHECKING: from typing import Tuple - from pygls.lsp.client import BaseLanguageClient + from pygls.lsp.client import LanguageClient @pytest_asyncio.fixture() @@ -34,7 +34,7 @@ async def goto(get_client_for): async def test_definition( - goto: Tuple[BaseLanguageClient, types.InitializeResult], path_for, uri_for + goto: Tuple[LanguageClient, types.InitializeResult], path_for, uri_for ): """Ensure that we can implement type definition requests.""" client, initialize_result = goto @@ -56,7 +56,7 @@ async def test_definition( ) ) - response = await client.text_document_definition_async( + response = await client.text_document_definition( types.DefinitionParams( text_document=types.TextDocumentIdentifier(uri=test_uri), position=types.Position(line=6, character=47), @@ -64,7 +64,7 @@ async def test_definition( ) assert response is None - response = await client.text_document_definition_async( + response = await client.text_document_definition( types.DefinitionParams( text_document=types.TextDocumentIdentifier(uri=test_uri), position=types.Position(line=5, character=20), diff --git a/tests/e2e/test_hover.py b/tests/e2e/test_hover.py index f41a36a3..8fedc9d3 100644 --- a/tests/e2e/test_hover.py +++ b/tests/e2e/test_hover.py @@ -26,7 +26,7 @@ from typing import List from typing import Tuple - from pygls.lsp.client import BaseLanguageClient + from pygls.lsp.client import LanguageClient @pytest_asyncio.fixture(scope="module") @@ -73,7 +73,7 @@ async def hover(get_client_for): ) @pytest.mark.asyncio(scope="module") async def test_hover( - hover: Tuple[BaseLanguageClient, types.InitializeResult], + hover: Tuple[LanguageClient, types.InitializeResult], uri_for, position: types.Position, expected: List[str], @@ -85,7 +85,7 @@ async def test_hover( assert hover_options is True test_uri = uri_for("dates.txt") - response = await client.text_document_hover_async( + response = await client.text_document_hover( types.HoverParams( position=position, text_document=types.TextDocumentIdentifier(uri=test_uri), diff --git a/tests/e2e/test_implementation.py b/tests/e2e/test_implementation.py index 6a10689a..1c7be618 100644 --- a/tests/e2e/test_implementation.py +++ b/tests/e2e/test_implementation.py @@ -24,7 +24,7 @@ if typing.TYPE_CHECKING: from typing import Tuple - from pygls.lsp.client import BaseLanguageClient + from pygls.lsp.client import LanguageClient @pytest_asyncio.fixture() @@ -34,7 +34,7 @@ async def goto(get_client_for): async def test_implementation( - goto: Tuple[BaseLanguageClient, types.InitializeResult], path_for, uri_for + goto: Tuple[LanguageClient, types.InitializeResult], path_for, uri_for ): """Ensure that we can implement type implementation requests.""" client, initialize_result = goto @@ -56,7 +56,7 @@ async def test_implementation( ) ) - response = await client.text_document_implementation_async( + response = await client.text_document_implementation( types.ImplementationParams( text_document=types.TextDocumentIdentifier(uri=test_uri), position=types.Position(line=6, character=47), @@ -64,7 +64,7 @@ async def test_implementation( ) assert response is None - response = await client.text_document_implementation_async( + response = await client.text_document_implementation( types.ImplementationParams( text_document=types.TextDocumentIdentifier(uri=test_uri), position=types.Position(line=5, character=46), diff --git a/tests/e2e/test_inlay_hints.py b/tests/e2e/test_inlay_hints.py index c764acfc..c1dd3034 100644 --- a/tests/e2e/test_inlay_hints.py +++ b/tests/e2e/test_inlay_hints.py @@ -24,7 +24,7 @@ if typing.TYPE_CHECKING: from typing import Tuple - from pygls.lsp.client import BaseLanguageClient + from pygls.lsp.client import LanguageClient @pytest_asyncio.fixture() @@ -34,7 +34,7 @@ async def inlay_hints(get_client_for): async def test_inlay_hints( - inlay_hints: Tuple[BaseLanguageClient, types.InitializeResult], uri_for + inlay_hints: Tuple[LanguageClient, types.InitializeResult], uri_for ): """Ensure that the example code action server is working as expected.""" client, initialize_result = inlay_hints @@ -43,9 +43,7 @@ async def test_inlay_hints( assert inlay_hint_provider.resolve_provider is True test_uri = uri_for("sums.txt") - assert test_uri is not None - - response = await client.text_document_inlay_hint_async( + response = await client.text_document_inlay_hint( types.InlayHintParams( text_document=types.TextDocumentIdentifier(uri=test_uri), range=types.Range( @@ -64,5 +62,5 @@ async def test_inlay_hints( assert three.label == ":11" assert three.tooltip is None - resolved = await client.inlay_hint_resolve_async(three) + resolved = await client.inlay_hint_resolve(three) assert resolved.tooltip == "Binary representation of the number: 3" diff --git a/tests/e2e/test_references.py b/tests/e2e/test_references.py index 2f9718f4..248448a4 100644 --- a/tests/e2e/test_references.py +++ b/tests/e2e/test_references.py @@ -24,7 +24,7 @@ if typing.TYPE_CHECKING: from typing import Tuple - from pygls.lsp.client import BaseLanguageClient + from pygls.lsp.client import LanguageClient @pytest_asyncio.fixture() @@ -34,7 +34,7 @@ async def goto(get_client_for): async def test_type_definition( - goto: Tuple[BaseLanguageClient, types.InitializeResult], path_for, uri_for + goto: Tuple[LanguageClient, types.InitializeResult], path_for, uri_for ): """Ensure that we can implement type definition requests.""" client, initialize_result = goto @@ -56,7 +56,7 @@ async def test_type_definition( ) ) - response = await client.text_document_references_async( + response = await client.text_document_references( types.ReferenceParams( context=types.ReferenceContext(include_declaration=True), text_document=types.TextDocumentIdentifier(uri=test_uri), @@ -65,7 +65,7 @@ async def test_type_definition( ) assert response is None - response = await client.text_document_references_async( + response = await client.text_document_references( types.ReferenceParams( context=types.ReferenceContext(include_declaration=True), text_document=types.TextDocumentIdentifier(uri=test_uri), diff --git a/tests/e2e/test_type_definition.py b/tests/e2e/test_type_definition.py index 36a673a6..ec35c4e1 100644 --- a/tests/e2e/test_type_definition.py +++ b/tests/e2e/test_type_definition.py @@ -24,7 +24,7 @@ if typing.TYPE_CHECKING: from typing import Tuple - from pygls.lsp.client import BaseLanguageClient + from pygls.lsp.client import LanguageClient @pytest_asyncio.fixture() @@ -34,7 +34,7 @@ async def goto(get_client_for): async def test_type_definition( - goto: Tuple[BaseLanguageClient, types.InitializeResult], path_for, uri_for + goto: Tuple[LanguageClient, types.InitializeResult], path_for, uri_for ): """Ensure that we can implement type definition requests.""" client, initialize_result = goto @@ -56,7 +56,7 @@ async def test_type_definition( ) ) - response = await client.text_document_type_definition_async( + response = await client.text_document_type_definition( types.TypeDefinitionParams( text_document=types.TextDocumentIdentifier(uri=test_uri), position=types.Position(line=6, character=47), @@ -64,7 +64,7 @@ async def test_type_definition( ) assert response is None - response = await client.text_document_type_definition_async( + response = await client.text_document_type_definition( types.TypeDefinitionParams( text_document=types.TextDocumentIdentifier(uri=test_uri), position=types.Position(line=5, character=52),