Add tests.

Author: chantera

tests/conftest.py

@@ -5,23 +5,19 @@
 import pytest
 from pylsp import uris
 from pylsp.config.config import Config
-from pylsp.workspace import Workspace, Document
-
+from pylsp.workspace import Document, Workspace
 
 here = Path(__file__).parent
 fixtures_dir = here / "fixtures"
 
 
 @pytest.fixture
 def config(workspace):
-    """Return a config object."""
     cfg = Config(workspace.root_uri, {}, 0, {})
     cfg._plugin_settings = {
         "plugins": {
-            "pylint": {
-                "enabled": False,
-                "args": [],
-                "executable": None,
+            "isort": {
+                "enabled": True,
             },
         },
     }
@@ -37,29 +33,13 @@ def workspace(tmpdir):
 
 
 @pytest.fixture
-def document(workspace):
-    return create_document(workspace, "simple.py")
+def unformatted_document(workspace):
+    return create_document(workspace, "unformatted.py")
 
 
 @pytest.fixture
-def code_action_context():
-    # https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#codeActionKind
-    code_action_kind = [
-        "",
-        "quickfix",
-        "refactor",
-        "refactor.extract",
-        "refactor.inline",
-        "refactor.rewrite",
-        "source",
-        "source.organizeImports",
-        "source.fixAll",
-    ]
-
-    return {
-        "diagnostics": [],
-        "only": code_action_kind,
-    }
+def formatted_document(workspace):
+    return create_document(workspace, "formatted.py")
 
 
 def create_document(workspace, name):

tests/fixtures/formatted.py

@@ -0,0 +1,9 @@
+from __future__ import absolute_import
+
+import os
+import sys
+
+from third_party import (lib1, lib2, lib3, lib4, lib5, lib6, lib7, lib8, lib9,
+                         lib10, lib11, lib12, lib13, lib14, lib15)
+
+from pylsp_isort.plugin import Range, isort_config, pylsp_settings

tests/fixtures/formatted_black.py

@@ -0,0 +1,24 @@
+from __future__ import absolute_import
+
+import os
+import sys
+
+from third_party import (
+    lib1,
+    lib2,
+    lib3,
+    lib4,
+    lib5,
+    lib6,
+    lib7,
+    lib8,
+    lib9,
+    lib10,
+    lib11,
+    lib12,
+    lib13,
+    lib14,
+    lib15,
+)
+
+from pylsp_isort.plugin import Range, isort_config, pylsp_settings

tests/fixtures/simple.py

@@ -0,0 +1,17 @@
+from pylsp_isort.plugin import isort_config
+
+import os
+
+from pylsp_isort.plugin import Range
+
+from pylsp_isort.plugin import pylsp_settings
+
+import sys
+
+from third_party import lib15, lib1, lib2, lib3, lib4, lib5, lib6, lib7, lib8, lib9, lib10, lib11, lib12, lib13, lib14
+
+import sys
+
+from __future__ import absolute_import
+
+from third_party import lib3

tests/fixtures/unformatted.py

@@ -1,96 +1,134 @@
-from unittest.mock import ANY
+import os
+from dataclasses import asdict
+
+import isort
+import pytest
 
 from pylsp_isort import plugin
-from test.conftest import *
 
 
-def test_definitions(config, workspace, document):
-    position = {"line": 3, "character": 6}
+def _read_content(filename):
+    path = os.path.join(os.path.dirname(__file__), "fixtures", filename)
+    with open(path) as f:
+        return f.read()
+
+
+@pytest.mark.parametrize(
+    ("text", "settings", "expected"),
+    [
+        (
+            _read_content("unformatted.py"),
+            {},
+            _read_content("formatted.py"),
+        ),
+        (
+            _read_content("unformatted.py"),
+            {"profile": "black"},
+            _read_content("formatted_black.py"),
+        ),
+    ],
+)
+def test_run_isort(text, settings, expected):
+    actual = plugin.run_isort(text, settings)
+    assert actual == expected
 
-    response = plugin.pylsp_definitions(
-        config=config,
-        workspace=workspace,
-        document=document,
-        position=position,
-    )
 
-    expected = [
-        {
-            "uri": ANY,
-            "range": {
-                "start": {
-                    "line": ANY,
-                    "character": ANY,
-                },
-                "end": {
-                    "line": ANY,
-                    "character": ANY,
-                },
-            },
-        },
-    ]
-
-    assert response == expected
-
-
-def test_code_action(config, workspace, document, code_action_context):
-    selection = {
-        "start": {
-            "line": 3,
-            "character": 0,
-        },
-        "end": {
-            "line": 4,
-            "character": 0,
-        },
-    }
-
-    response = plugin.pylsp_code_actions(
-        config=config,
-        workspace=workspace,
-        document=document,
-        range=selection,
-        context=code_action_context,
+@pytest.mark.parametrize(
+    ("settings", "target_path", "expected", "check_sources"),
+    [
+        (
+            {},
+            None,
+            isort.Config(),
+            True,
+        ),
+        (
+            {"profile": "black"},
+            None,
+            isort.Config(profile="black"),
+            True,
+        ),
+        (
+            {"profile": "black", "line_length": 120},
+            None,
+            isort.Config(profile="black", line_length=120),
+            True,
+        ),
+        (
+            {},
+            __file__,
+            isort.Config(settings_path=os.path.dirname(__file__)),
+            True,
+        ),
+        (
+            {},
+            __file__,
+            isort.Config(profile="black"),
+            False,
+        ),
+    ],
+)
+def test_isort_config(settings, target_path, expected, check_sources):
+    actual = plugin.isort_config(settings, target_path)
+    actual_dict = asdict(actual)
+    expected_dict = asdict(expected)
+    if not check_sources:
+        del actual_dict["sources"]
+        del expected_dict["sources"]
+    assert actual_dict == expected_dict
+
+
+def test_pylsp_format_document(config, unformatted_document, formatted_document):
+    actual = _receive(plugin.pylsp_format_document, config, unformatted_document)
+
+    text = _read_content(formatted_document.path)
+    range = plugin.Range(
+        start={"line": 0, "character": 0},
+        end={"line": len(unformatted_document.lines), "character": 0},
     )
+    expected = [{"range": range, "newText": text}]
+
+    assert actual == expected
 
-    expected = [
-        {
-            "title": "Extract method",
-            "kind": "refactor.extract",
-            "command": {
-                "command": "example.refactor.extract",
-                "arguments": [document.uri, selection],
-            },
-        },
-    ]
-
-    assert response == expected
-
-    command = response[0]["command"]["command"]
-    arguments = response[0]["command"]["arguments"]
-
-    response = plugin.pylsp_execute_command(
-        config=config,
-        workspace=workspace,
-        command=command,
-        arguments=arguments,
+
+def test_pylsp_format_range(config, unformatted_document):
+    range = plugin.Range(
+        start={"line": 2, "character": 0},
+        end={"line": 9, "character": 0},
     )
+    actual = _receive(plugin.pylsp_format_range, config, unformatted_document, range)
 
-    workspace._endpoint.request.assert_called_once_with(
-        "workspace/applyEdit",
-        {
-            "edit": {
-                "changes": {
-                    document.uri: [
-                        {
-                            "range": {
-                                "start": {"line": 3, "character": 0},
-                                "end": {"line": 4, "character": 0},
-                            },
-                            "newText": "replacement text",
-                        },
-                    ],
-                },
-            },
-        },
+    text = "\n".join(
+        [
+            "import os",
+            "import sys",
+            "",
+            "from pylsp_isort.plugin import Range, pylsp_settings",
+        ]
     )
+    text += "\n"
+    expected = [{"range": range, "newText": text}]
+
+    assert actual == expected
+
+
+def _receive(func, *args):
+    gen = func(*args)
+    next(gen)
+    outcome = MockResult([])
+    try:
+        gen.send(outcome)
+    except StopIteration:
+        pass
+    return outcome.get_result()
+
+
+class MockResult:
+    def __init__(self, result):
+        self.result = result
+
+    def get_result(self):
+        return self.result
+
+    def force_result(self, result):
+        self.result = result