Converge unit tests for test_language_server and test_notebook_document

Author: tkrabel-db

test/fixtures.py

@@ -5,6 +5,8 @@
 from io import StringIO
 from unittest.mock import MagicMock
 
+from test.test_utils import ClientServerPair
+
 import pytest
 from pylsp_jsonrpc.dispatchers import MethodDispatcher
 from pylsp_jsonrpc.endpoint import Endpoint
@@ -22,12 +24,14 @@
 def main():
     print sys.stdin.read()
 """
+CALL_TIMEOUT_IN_SECONDS = 30
 
 
 class FakeEditorMethodsMixin:
     """
     Represents the methods to be added to a dispatcher class when faking an editor.
     """
+
     def m_window__work_done_progress__create(self, *_args, **_kwargs):
         """
         Fake editor method `window/workDoneProgress/create`.
@@ -52,6 +56,7 @@ class FakeEndpoint(Endpoint):
     Fake methods in the `dispatcher` should raise `JsonRpcException` for any
     error.
     """
+
     def request(self, method, params=None):
         request_future = super().request(method, params)
         try:
@@ -64,40 +69,32 @@ def request(self, method, params=None):
 
 @pytest.fixture
 def pylsp(tmpdir):
-    """ Return an initialized python LS """
+    """Return an initialized python LS"""
     ls = FakePythonLSPServer(StringIO, StringIO, endpoint_cls=FakeEndpoint)
 
     ls.m_initialize(
-        processId=1,
-        rootUri=uris.from_fs_path(str(tmpdir)),
-        initializationOptions={}
+        processId=1, rootUri=uris.from_fs_path(str(tmpdir)), initializationOptions={}
     )
 
     return ls
 
 
 @pytest.fixture
 def pylsp_w_workspace_folders(tmpdir):
-    """ Return an initialized python LS """
+    """Return an initialized python LS"""
     ls = FakePythonLSPServer(StringIO, StringIO, endpoint_cls=FakeEndpoint)
 
-    folder1 = tmpdir.mkdir('folder1')
-    folder2 = tmpdir.mkdir('folder2')
+    folder1 = tmpdir.mkdir("folder1")
+    folder2 = tmpdir.mkdir("folder2")
 
     ls.m_initialize(
         processId=1,
         rootUri=uris.from_fs_path(str(folder1)),
         initializationOptions={},
         workspaceFolders=[
-            {
-                'uri': uris.from_fs_path(str(folder1)),
-                'name': 'folder1'
-            },
-            {
-                'uri': uris.from_fs_path(str(folder2)),
-                'name': 'folder2'
-            }
-        ]
+            {"uri": uris.from_fs_path(str(folder1)), "name": "folder1"},
+            {"uri": uris.from_fs_path(str(folder2)), "name": "folder2"},
+        ],
     )
 
     workspace_folders = [folder1, folder2]
@@ -129,7 +126,7 @@ def workspace(tmpdir, endpoint):  # pylint: disable=redefined-outer-name
 @pytest.fixture
 def workspace_other_root_path(tmpdir, endpoint):  # pylint: disable=redefined-outer-name
     """Return a workspace with a root_path other than tmpdir."""
-    ws_path = str(tmpdir.mkdir('test123').mkdir('test456'))
+    ws_path = str(tmpdir.mkdir("test123").mkdir("test456"))
     ws = Workspace(uris.from_fs_path(ws_path), endpoint)
     ws._config = Config(ws.root_uri, {}, 0, {})
     return ws
@@ -139,7 +136,9 @@ def workspace_other_root_path(tmpdir, endpoint):  # pylint: disable=redefined-ou
 def config(workspace):  # pylint: disable=redefined-outer-name
     """Return a config object."""
     cfg = Config(workspace.root_uri, {}, 0, {})
-    cfg._plugin_settings = {'plugins': {'pylint': {'enabled': False, 'args': [], 'executable': None}}}
+    cfg._plugin_settings = {
+        "plugins": {"pylint": {"enabled": False, "args": [], "executable": None}}
+    }
     return cfg
 
 
@@ -150,14 +149,15 @@ def doc(workspace):  # pylint: disable=redefined-outer-name
 
 @pytest.fixture
 def temp_workspace_factory(workspace):  # pylint: disable=redefined-outer-name
-    '''
+    """
     Returns a function that creates a temporary workspace from the files dict.
     The dict is in the format {"file_name": "file_contents"}
-    '''
+    """
+
     def fn(files):
         def create_file(name, content):
             fn = os.path.join(workspace.root_path, name)
-            with open(fn, 'w', encoding='utf-8') as f:
+            with open(fn, "w", encoding="utf-8") as f:
                 f.write(content)
             workspace.put_document(uris.from_fs_path(fn), content)
 
@@ -166,3 +166,17 @@ def create_file(name, content):
         return workspace
 
     return fn
+
+
+@pytest.fixture
+def client_server_pair():
+    """A fixture that sets up a client/server pair and shuts down the server"""
+    client_server_pair_obj = ClientServerPair()
+
+    yield (client_server_pair_obj.client, client_server_pair_obj.server)
+
+    shutdown_response = client_server_pair_obj.client._endpoint.request(
+        "shutdown"
+    ).result(timeout=CALL_TIMEOUT_IN_SECONDS)
+    assert shutdown_response is None
+    client_server_pair_obj.client._endpoint.notify("exit")

test/test_language_server.py

@@ -3,118 +3,92 @@
 
 import os
 import time
-import multiprocessing
 import sys
-from threading import Thread
+
+from test.test_utils import ClientServerPair
 
 from flaky import flaky
 from pylsp_jsonrpc.exceptions import JsonRpcMethodNotFound
 import pytest
 
-from pylsp.python_lsp import start_io_lang_server, PythonLSPServer
-
-CALL_TIMEOUT = 10
-RUNNING_IN_CI = bool(os.environ.get('CI'))
-
-
-def start_client(client):
-    client.start()
-
-
-class _ClientServer:
-    """ A class to setup a client/server pair """
-    def __init__(self, check_parent_process=False):
-        # Client to Server pipe
-        csr, csw = os.pipe()
-        # Server to client pipe
-        scr, scw = os.pipe()
-
-        if os.name == 'nt':
-            ParallelKind = Thread
-        else:
-            if sys.version_info[:2] >= (3, 8):
-                ParallelKind = multiprocessing.get_context("fork").Process
-            else:
-                ParallelKind = multiprocessing.Process
-
-        self.process = ParallelKind(target=start_io_lang_server, args=(
-            os.fdopen(csr, 'rb'), os.fdopen(scw, 'wb'), check_parent_process, PythonLSPServer
-        ))
-        self.process.start()
-
-        self.client = PythonLSPServer(os.fdopen(scr, 'rb'), os.fdopen(csw, 'wb'), start_io_lang_server)
-        self.client_thread = Thread(target=start_client, args=[self.client])
-        self.client_thread.daemon = True
-        self.client_thread.start()
-
-
-@pytest.fixture
-def client_server():
-    """ A fixture that sets up a client/server pair and shuts down the server
-    This client/server pair does not support checking parent process aliveness
-    """
-    client_server_pair = _ClientServer()
 
-    yield client_server_pair.client
+RUNNING_IN_CI = bool(os.environ.get("CI"))
 
-    shutdown_response = client_server_pair.client._endpoint.request('shutdown').result(timeout=CALL_TIMEOUT)
-    assert shutdown_response is None
-    client_server_pair.client._endpoint.notify('exit')
+CALL_TIMEOUT_IN_SECONDS = 10
 
 
 @pytest.fixture
 def client_exited_server():
-    """ A fixture that sets up a client/server pair that support checking parent process aliveness
+    """A fixture that sets up a client/server pair that support checking parent process aliveness
     and assert the server has already exited
     """
-    client_server_pair = _ClientServer(True)
+    client_server_pair_obj = ClientServerPair(True, True)
 
-    # yield client_server_pair.client
-    yield client_server_pair
+    yield client_server_pair_obj
 
-    assert client_server_pair.process.is_alive() is False
+    assert client_server_pair_obj.server_process.is_alive() is False
 
 
 @flaky(max_runs=10, min_passes=1)
-@pytest.mark.skipif(sys.platform == 'darwin', reason='Too flaky on Mac')
-def test_initialize(client_server):  # pylint: disable=redefined-outer-name
-    response = client_server._endpoint.request('initialize', {
-        'rootPath': os.path.dirname(__file__),
-        'initializationOptions': {}
-    }).result(timeout=CALL_TIMEOUT)
-    assert 'capabilities' in response
+@pytest.mark.skipif(sys.platform == "darwin", reason="Too flaky on Mac")
+def test_initialize(client_server_pair):
+    client, _ = client_server_pair
+    response = client._endpoint.request(
+        "initialize",
+        {"rootPath": os.path.dirname(__file__), "initializationOptions": {}},
+    ).result(timeout=CALL_TIMEOUT_IN_SECONDS)
+    assert "capabilities" in response
 
 
 @flaky(max_runs=10, min_passes=1)
-@pytest.mark.skipif(not sys.platform.startswith('Linux'), reason='Skipped on win and flaky on mac')
-def test_exit_with_parent_process_died(client_exited_server):  # pylint: disable=redefined-outer-name
+@pytest.mark.skipif(
+    not sys.platform.startswith("Linux"), reason="Skipped on win and flaky on mac"
+)
+def test_exit_with_parent_process_died(
+    client_exited_server,
+):  # pylint: disable=redefined-outer-name
     # language server should have already exited before responding
-    lsp_server, mock_process = client_exited_server.client, client_exited_server.process
+    lsp_server, mock_process = (
+        client_exited_server.client,
+        client_exited_server.server_process,
+    )
     # with pytest.raises(Exception):
-    lsp_server._endpoint.request('initialize', {
-        'processId': mock_process.pid,
-        'rootPath': os.path.dirname(__file__),
-        'initializationOptions': {}
-    }).result(timeout=CALL_TIMEOUT)
+    lsp_server._endpoint.request(
+        "initialize",
+        {
+            "processId": mock_process.pid,
+            "rootPath": os.path.dirname(__file__),
+            "initializationOptions": {},
+        },
+    ).result(timeout=CALL_TIMEOUT_IN_SECONDS)
 
     mock_process.terminate()
-    time.sleep(CALL_TIMEOUT)
+    time.sleep(CALL_TIMEOUT_IN_SECONDS)
     assert not client_exited_server.client_thread.is_alive()
 
 
 @flaky(max_runs=10, min_passes=1)
-@pytest.mark.skipif(sys.platform.startswith('linux'), reason='Fails on linux')
-def test_not_exit_without_check_parent_process_flag(client_server):  # pylint: disable=redefined-outer-name
-    response = client_server._endpoint.request('initialize', {
-        'processId': 1234,
-        'rootPath': os.path.dirname(__file__),
-        'initializationOptions': {}
-    }).result(timeout=CALL_TIMEOUT)
-    assert 'capabilities' in response
+@pytest.mark.skipif(sys.platform.startswith("linux"), reason="Fails on linux")
+def test_not_exit_without_check_parent_process_flag(
+    client_server_pair,
+):
+    client, _ = client_server_pair
+    response = client._endpoint.request(
+        "initialize",
+        {
+            "processId": 1234,
+            "rootPath": os.path.dirname(__file__),
+            "initializationOptions": {},
+        },
+    ).result(timeout=CALL_TIMEOUT_IN_SECONDS)
+    assert "capabilities" in response
 
 
 @flaky(max_runs=10, min_passes=1)
-@pytest.mark.skipif(RUNNING_IN_CI, reason='This test is hanging on CI')
-def test_missing_message(client_server):  # pylint: disable=redefined-outer-name
+@pytest.mark.skipif(RUNNING_IN_CI, reason="This test is hanging on CI")
+def test_missing_message(client_server_pair):
+    client, _ = client_server_pair
     with pytest.raises(JsonRpcMethodNotFound):
-        client_server._endpoint.request('unknown_method').result(timeout=CALL_TIMEOUT)
+        client._endpoint.request("unknown_method").result(
+            timeout=CALL_TIMEOUT_IN_SECONDS
+        )