refactor: wip unit tests

tests/lsp/test_protocol.py

@@ -0,0 +1,118 @@
+import json
+
+import pytest
+from lsprotocol import types
+
+from pygls.lsp.protocol import LanguageServerProtocol
+from pygls.lsp.protocol import default_converter
+
+
+@pytest.mark.parametrize(
+    "method, params, expected",
+    [
+        (
+            types.TEXT_DOCUMENT_COMPLETION,
+            types.CompletionParams(
+                text_document=types.TextDocumentIdentifier(uri="file:///file.txt"),
+                position=types.Position(line=1, character=0),
+            ),
+            {
+                "jsonrpc": "2.0",
+                "id": "1",
+                "method": types.TEXT_DOCUMENT_COMPLETION,
+                "params": {
+                    "textDocument": {"uri": "file:///file.txt"},
+                    "position": {"line": 1, "character": 0},
+                },
+            },
+        ),
+    ],
+)
+def test_encode_request(method, params, expected):
+    """Ensure that we can encode request messages."""
+
+    protocol = LanguageServerProtocol(default_converter)
+    data = protocol.encode_request(method, params, msg_id="1", include_headers=False)
+    actual = json.loads(data.decode("utf8"))
+
+    assert actual == expected
+
+
+@pytest.mark.parametrize(
+    "msg_type, result, expected",
+    [
+        (types.ShutdownResponse, None, {"jsonrpc": "2.0", "id": "1", "result": None}),
+        (
+            types.TextDocumentCompletionResponse,
+            [
+                types.CompletionItem(label="example-one"),
+                types.CompletionItem(
+                    label="example-two",
+                    kind=types.CompletionItemKind.Class,
+                    preselect=False,
+                    deprecated=True,
+                ),
+            ],
+            {
+                "jsonrpc": "2.0",
+                "id": "1",
+                "result": [
+                    {"label": "example-one"},
+                    {
+                        "label": "example-two",
+                        "kind": 7,  # CompletionItemKind.Class
+                        "preselect": False,
+                        "deprecated": True,
+                    },
+                ],
+            },
+        ),
+    ],
+)
+def test_encode_response(msg_type, result, expected):
+    """Ensure that we can serialize response messages"""
+
+    protocol = LanguageServerProtocol(default_converter)
+    protocol._result_types["1"] = msg_type
+
+    data = protocol.encode_result("1", result=result, include_headers=False)
+    actual = json.loads(data.decode("utf8"))
+
+    assert actual == expected
+
+
+@pytest.mark.parametrize(
+    "method, params, expected",
+    [
+        (
+            types.PROGRESS,
+            types.ProgressParams(
+                token="id1",
+                value=types.WorkDoneProgressBegin(
+                    title="Begin progress",
+                    percentage=0,
+                ),
+            ),
+            {
+                "jsonrpc": "2.0",
+                "method": "$/progress",
+                "params": {
+                    "token": "id1",
+                    "value": {
+                        "kind": "begin",
+                        "percentage": 0,
+                        "title": "Begin progress",
+                    },
+                },
+            },
+        ),
+    ],
+)
+def test_encode_notification(method, params, expected):
+    """Ensure that we can encode notification messages"""
+
+    protocol = LanguageServerProtocol(default_converter)
+    data = protocol.encode_notification(method, params=params, include_headers=False)
+    actual = json.loads(data.decode("utf8"))
+
+    assert actual == expected

tests/servers/invalid_json.py

@@ -1,25 +1,25 @@
 """This server does nothing but print invalid JSON."""
 import asyncio
-import threading
 import sys
-from concurrent.futures import ThreadPoolExecutor
+import threading
+from functools import partial
 
-from pygls.server import aio_readline
+from pygls.protocol import rpc_main_loop
+from pygls.server._async_server import get_sdtio_streams
 
 
-def handler(data):
+def write_data(writer: asyncio.StreamWriter, data):
     content = 'Content-Length: 5\r\n\r\n{"ll}'.encode("utf8")
-    sys.stdout.buffer.write(content)
-    sys.stdout.flush()
+    writer.write(content)
 
 
 async def main():
-    await aio_readline(
-        asyncio.get_running_loop(),
-        ThreadPoolExecutor(),
-        threading.Event(),
-        sys.stdin.buffer,
-        handler,
+    reader, writer = await get_sdtio_streams(sys.stdin.buffer, sys.stdout.buffer)
+
+    await rpc_main_loop(
+        reader=reader,
+        stop_event=threading.Event(),
+        message_handler=partial(write_data, writer),
     )
 
 

tests/servers/large_response.py

@@ -1,13 +1,14 @@
 """This server returns a particuarly large response."""
 import asyncio
-import threading
 import sys
-from concurrent.futures import ThreadPoolExecutor
+import threading
+from functools import partial
 
-from pygls.server import aio_readline
+from pygls.protocol import rpc_main_loop
+from pygls.server._async_server import get_sdtio_streams
 
 
-def handler(data):
+def write_data(writer, data):
     payload = dict(
         jsonrpc="2.0",
         id=1,
@@ -18,17 +19,16 @@ def handler(data):
     content = str(payload).replace("'", '"')
     message = f"Content-Length: {len(content)}\r\n\r\n{content}".encode("utf8")
 
-    sys.stdout.buffer.write(message)
-    sys.stdout.flush()
+    writer.write(message)
 
 
 async def main():
-    await aio_readline(
-        asyncio.get_running_loop(),
-        ThreadPoolExecutor(),
-        threading.Event(),
-        sys.stdin.buffer,
-        handler,
+    reader, writer = await get_sdtio_streams(sys.stdin.buffer, sys.stdout.buffer)
+
+    await rpc_main_loop(
+        reader=reader,
+        stop_event=threading.Event(),
+        message_handler=partial(write_data, writer),
     )
 
 

tests/servers/rpc.py

@@ -0,0 +1,21 @@
+"""A generic JSON-RPC server"""
+import asyncio
+import logging
+from typing import Dict
+
+from pygls.server import JsonRPCServer
+
+server = JsonRPCServer()
+
+
+@server.feature("math/add")
+def add(params: Dict[str, float]):
+    a = params["a"]
+    b = params["b"]
+
+    return dict(sum=a + b)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.DEBUG, filename="server.log", filemode="w")
+    asyncio.run(server.start_io())

tests/test_client.py

@@ -17,20 +17,15 @@
 import asyncio
 import pathlib
 import sys
-from typing import Union
 
 import pytest
-from pygls import IS_PYODIDE
 
 from pygls.client import JsonRPCClient
-from pygls.exceptions import JsonRpcException, PyglsError
-
 
 SERVERS = pathlib.Path(__file__).parent / "servers"
 
 
 @pytest.mark.asyncio
-@pytest.mark.skipif(IS_PYODIDE, reason="Subprocesses are not available on pyodide.")
 async def test_client_detect_server_exit():
     """Ensure that the client detects when the server process exits."""
 
@@ -51,7 +46,6 @@ async def server_exit(self, server: asyncio.subprocess.Process):
 
 
 @pytest.mark.asyncio
-@pytest.mark.skipif(IS_PYODIDE, reason="Subprocesses are not available on pyodide.")
 async def test_client_detect_invalid_json():
     """Ensure that the client can detect the case where the server returns invalid
     json."""
@@ -60,43 +54,34 @@ class TestClient(JsonRPCClient):
         report_error_called = False
         future = None
 
-        def report_server_error(
-            self, error: Exception, source: Union[PyglsError, JsonRpcException]
-        ):
+        def error_handler(self, error: Exception):
             self.report_error_called = True
-            self.future.cancel()
-
-            self._server.kill()
-            self._stop_event.set()
-
             assert "Unterminated string" in str(error)
 
     client = TestClient()
     await client.start_io(sys.executable, str(SERVERS / "invalid_json.py"))
 
-    future = client.protocol.send_request_async("method/name", {})
-    client.future = future
-
+    cancelled = False
     try:
-        await future
-    except asyncio.CancelledError:
-        pass  # Ignore the exception generated by cancelling the future
-    finally:
-        await client.stop()
+        await asyncio.wait_for(
+            client.send_request("method/name", {}), timeout=5.0  # seconds
+        )
+    except asyncio.TimeoutError:
+        assert_message = "Expected `error_handler` to have been called"
+        assert client.report_error_called, assert_message
+        cancelled = True
 
-    assert_message = "Expected `report_server_error` to have been called"
-    assert client.report_error_called, assert_message
+    assert cancelled is True, "Expected request to have been cancelled."
 
 
 @pytest.mark.asyncio
-@pytest.mark.skipif(IS_PYODIDE, reason="Subprocesses are not available on pyodide.")
 async def test_client_large_responses():
     """Ensure that the client can correctly handle large responses from a server."""
 
     client = JsonRPCClient()
     await client.start_io(sys.executable, str(SERVERS / "large_response.py"))
 
-    result = await client.protocol.send_request_async("get/numbers", {}, msg_id=1)
-    assert len(result.numbers) == 100_000
+    result = await client.send_request("get/numbers", {}, msg_id=1)
+    assert len(result["numbers"]) == 100_000
 
     await client.stop()