Fix test_implementations by using real on-FS file

Author: smheidrich

test/data/implementations_examples/example.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+
+class Animal(ABC):
+    @abstractmethod
+    def breathe(self):
+        pass
+
+    @property
+    @abstractmethod
+    def size(self) -> str:
+        pass
+
+class WingedAnimal(Animal):
+    @abstractmethod
+    def fly(self, destination):
+        pass
+
+class Bird(WingedAnimal):
+    def breathe(self):
+        print("*inhales like a bird*")
+
+    def fly(self, destination):
+        print("*flies like a bird*")
+
+    @property
+    def size(self) -> str:
+        return "bird-sized"
+
+print("not a method at all")

test/plugins/test_implementations.py

@@ -1,142 +1,104 @@
 # Copyright 2017-2020 Palantir Technologies, Inc.
 # Copyright 2021- Python Language Server Contributors.
 
-import os
+from collections.abc import Iterable
+from importlib.resources import as_file, files
+from pathlib import Path
 
 import pytest
+from rope.base.exceptions import BadIdentifierError
 
 from pylsp import uris
+from pylsp.config.config import Config
 from pylsp.plugins.rope_implementation import pylsp_implementations
-from pylsp.workspace import Document
+from pylsp.workspace import Workspace
 
-DOC_URI = uris.from_fs_path(__file__)
-DOC = """
-from abc import ABC, abstractmethod
 
-class Animal(ABC):
-    @abstractmethod
-    def breathe(self):
-        ...
+# We use a real file because the part of Rope that this feature uses
+# (`rope.findit.find_implementations`) *always* loads files from the
+# filesystem, in contrast to e.g. `code_assist` which takes a `source` argument
+# that can be more easily faked.
+# An alternative to using real files would be `unittest.mock.patch`, but that
+# ends up being more trouble than it's worth...
+@pytest.fixture
+def examples_dir_path() -> Iterable[Path]:
+    with as_file(files("test.data.implementations_examples")) as path:
+        yield path
 
-    @property
-    @abstractmethod
-    def size(self) -> str:
-        ...
 
-class WingedAnimal(Animal):
-    @abstractmethod
-    def fly(self, destination):
-        ...
+@pytest.fixture
+def doc_uri(examples_dir_path: Path) -> str:
+    return uris.from_fs_path(str(examples_dir_path / "example.py"))
 
-class Bird(WingedAnimal):
-    def breathe(self):
-        print("*inhales like a bird*")
 
-    def fly(self, destination):
-        print("*flies like a bird*")
+# Similarly to the above, we need our workspace to point to the actual location
+# on the filesystem containing the example modules, so we override the fixture:
+@pytest.fixture
+def workspace(examples_dir_path: Path, endpoint) -> None:
+    ws = Workspace(uris.from_fs_path(str(examples_dir_path)), endpoint)
+    ws._config = Config(ws.root_uri, {}, 0, {})
+    yield ws
+    ws.close()
 
-    @property
-    def size(self) -> str:
-        return "bird-sized"
 
-print("not a method at all")
-"""
-
-
-def test_implementations(config, workspace) -> None:
+def test_implementations(config, workspace, doc_uri) -> None:
     # Over 'fly' in WingedAnimal.fly
-    cursor_pos = {"line": 15, "character": 9}
+    cursor_pos = {"line": 14, "character": 8}
 
     # The implementation of 'Bird.fly'
     def_range = {
-        "start": {"line": 22, "character": 0},
-        "end": {"line": 22, "character": 999},
+        "start": {"line": 21, "character": 0},
+        "end": {"line": 21, "character": 999},
     }
 
-    workspace.put_document(DOC_URI, DOC)
-    doc = workspace.get_document(DOC_URI)
-    assert [{"uri": DOC_URI, "range": def_range}] == pylsp_implementations(
+    doc = workspace.get_document(doc_uri)
+    assert [{"uri": doc_uri, "range": def_range}] == pylsp_implementations(
         config, workspace, doc, cursor_pos
     )
 
 
-def test_implementations_skipping_one_class(config, workspace) -> None:
+def test_implementations_skipping_one_class(config, workspace, doc_uri) -> None:
     # Over 'Animal.breathe'
-    cursor_pos = {"line": 15, "character": 9}
+    cursor_pos = {"line": 4, "character": 8}
 
     # The implementation of 'breathe', skipping intermediate classes
     def_range = {
-        "start": {"line": 19, "character": 0},
-        "end": {"line": 19, "character": 999},
+        "start": {"line": 18, "character": 0},
+        "end": {"line": 18, "character": 999},
     }
 
-    doc = Document(DOC_URI, workspace, DOC)
-    assert [{"uri": DOC_URI, "range": def_range}] == pylsp_implementations(
+    doc = workspace.get_document(doc_uri)
+    assert [{"uri": doc_uri, "range": def_range}] == pylsp_implementations(
         config, workspace, doc, cursor_pos
     )
 
 
-@pytest.mark.xfail(reason="not implemented upstream (Rope)", strict=True)
-def test_property_implementations(config, workspace) -> None:
+@pytest.mark.xfail(
+    reason="not implemented upstream (Rope)", strict=True, raises=BadIdentifierError
+)
+def test_property_implementations(config, workspace, doc_uri) -> None:
     # Over 'Animal.size'
-    cursor_pos = {"line": 10, "character": 9}
+    cursor_pos = {"line": 9, "character": 9}
 
     # The property implementation 'Bird.size'
     def_range = {
-        "start": {"line": 26, "character": 0},
-        "end": {"line": 26, "character": 999},
+        "start": {"line": 25, "character": 0},
+        "end": {"line": 25, "character": 999},
     }
 
-    doc = Document(DOC_URI, workspace, DOC)
-    assert [{"uri": DOC_URI, "range": def_range}] == pylsp_implementations(
+    doc = workspace.get_document(doc_uri)
+    assert [{"uri": doc_uri, "range": def_range}] == pylsp_implementations(
         config, workspace, doc, cursor_pos
     )
 
 
-def test_no_implementations_if_not_a_method(config, workspace) -> None:
-    # Over 'print(...)' call
-    cursor_pos = {"line": 26, "character": 0}
-
-    doc = Document(DOC_URI, workspace, DOC)
-    assert [] == pylsp_implementations(config, workspace, doc, cursor_pos)
-
+def test_implementations_not_a_method(config, workspace, doc_uri) -> None:
+    # Over 'print(...)' call => Rope error because not a method.
+    cursor_pos = {"line": 28, "character": 0}
 
-def test_document_path_implementations(
-    config, workspace, workspace_other_root_path, tmpdir
-) -> None:
-    # Create a dummy module out of the workspace's root_path and try to get
-    # a implementation on it in another file placed next to it.
-    module_content = """
-class A:
-    def f():
-"""
+    doc = workspace.get_document(doc_uri)
 
-    p = tmpdir.join("mymodule.py")
-    p.write(module_content)
-
-    # Content of doc to test implementation
-    doc_content = """
-from mymodule import A
-class B(A):
-    def f():
-"""
-    doc_path = str(tmpdir) + os.path.sep + "myfile.py"
-    doc_uri = uris.from_fs_path(doc_path)
-    doc = Document(doc_uri, workspace_other_root_path, doc_content)
-
-    # The range where f is defined in mymodule.py
-    def_range = {
-        "start": {"line": 2, "character": 0},
-        "end": {"line": 2, "character": 999},
-    }
-
-    # The position where foo is called in myfile.py
-    cursor_pos = {"line": 3, "character": 9}
-
-    # The uri for mymodule.py
-    module_path = str(p)
-    module_uri = uris.from_fs_path(module_path)
-
-    assert [{"uri": module_uri, "range": def_range}] == pylsp_implementations(
-        config, workspace, doc, cursor_pos
-    )
+    # This exception is turned into an empty result set automatically in upper
+    # layers, so we just check that it is raised to document this behavior:
+    with pytest.raises(BadIdentifierError):
+        pylsp_implementations(config, workspace, doc, cursor_pos)