jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/langserve/tests/server_test/test_lang_serve.py

@@ -0,0 +1,262 @@
+"""Test for Jac language server[VSCE] features"""
+import os
+import pytest
+
+from lsprotocol.types import (
+    DidOpenTextDocumentParams,
+    TextDocumentItem,
+    DidSaveTextDocumentParams,
+    DidChangeTextDocumentParams,
+    DocumentFormattingParams,
+    TextEdit,
+    VersionedTextDocumentIdentifier,
+    TextDocumentIdentifier,
+)
+from jaclang.langserve.engine import JacLangServer
+from jaclang.langserve.server import (
+    did_open,
+    did_save,
+    did_change,
+    formatting,
+)
+from jaclang.langserve.tests.server_test.utils import (
+    create_temp_jac_file,
+    get_code,
+    get_jac_file_path,
+    create_ls_with_workspace,  # new helper
+)
+from jaclang.vendor.pygls.uris import from_fs_path
+from jaclang.vendor.pygls.workspace import Workspace
+
+JAC_FILE = get_jac_file_path()
+
+class TestLangServe:
+    """Test class for Jac language server features."""
+
+    @pytest.mark.asyncio
+    async def test_open_valid_file_no_diagnostics(self):
+        """Test opening a Jac file with a syntax error."""
+        ls = JacLangServer()
+
+        code = get_code("")
+        temp_file_path = create_temp_jac_file(code)
+        uri = from_fs_path(temp_file_path)
+        ls.lsp._workspace = Workspace(os.path.dirname(temp_file_path), ls)
+
+        params = DidOpenTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=1,
+                text=code,
+            )
+        )
+        await did_open(ls, params)
+
+        diagnostics = ls.diagnostics.get(uri, [])
+        ls.shutdown()
+        assert len(diagnostics) == 0
+
+        os.remove(temp_file_path)
+
+    @pytest.mark.asyncio
+    async def test_open_with_syntax_error(self):
+        """Test opening a Jac file with a syntax error."""
+        ls = JacLangServer()
+
+        code = get_code("error")
+        temp_file_path = create_temp_jac_file(code)
+        uri = from_fs_path(temp_file_path)
+        ls.lsp._workspace = Workspace(os.path.dirname(temp_file_path), ls)
+
+        params = DidOpenTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=1,
+                text=code,
+            )
+        )
+        await did_open(ls, params)
+
+        diagnostics = ls.diagnostics.get(uri, [])
+        ls.shutdown()
+        assert len(diagnostics) == 1
+        assert diagnostics[0].message == "Syntax Error"
+        assert str(diagnostics[0].range) == "66:0-66:1"
+
+        os.remove(temp_file_path)
+
+    @pytest.mark.asyncio
+    async def test_did_open_and_simple_syntax_error(self):
+        """Test diagnostics for a Jac file with a syntax error."""
+        ls = JacLangServer()
+
+        code = get_code("")
+        temp_file_path = create_temp_jac_file(code)
+        uri = from_fs_path(temp_file_path)
+        ls.lsp._workspace = Workspace(os.path.dirname(temp_file_path), ls)
+    
+        params = DidOpenTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=1,
+                text=code,
+            )
+        )
+        await did_open(ls, params)
+        diagnostics = ls.diagnostics.get(uri, [])
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == 0
+
+        broken_code = get_code("error")
+        with open(temp_file_path, "w") as f:
+            f.write(broken_code)
+        params = DidOpenTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=1,
+                text=broken_code,
+            )
+        )
+        await did_open(ls, params)
+        diagnostics = ls.diagnostics.get(uri, [])
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == 1
+
+        sem_tokens = ls.get_semantic_tokens(uri)
+        print(sem_tokens)
+        ls.shutdown()
+        assert hasattr(sem_tokens, "data")
+        assert isinstance(sem_tokens.data, list)
+        assert len(sem_tokens.data) == 0 # TODO: we should retain the sem tokens, will be fixed in next PR 
+
+        os.remove(temp_file_path)
+
+    @pytest.mark.asyncio
+    async def test_did_save(self):
+        """Test saving a Jac file triggers diagnostics."""
+        code = get_code("")
+        temp_file_path = create_temp_jac_file(code)
+        uri, ls = create_ls_with_workspace(temp_file_path)
+
+        await did_open(ls, DidOpenTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=1,
+                text=code,
+            )
+        ))
+
+        params = DidSaveTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=2,
+                text=code,
+            )
+        )
+
+        await did_save(ls, params)
+        diagnostics = ls.diagnostics.get(uri, [])
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == 0
+
+        # Now simulate a syntax error by updating the workspace and saving
+        broken_code = get_code("error")
+        ls.workspace.put_text_document(TextDocumentItem(
+            uri=uri,
+            language_id="jac",
+            version=3,
+            text=broken_code,
+        ))
+        params = DidSaveTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=3,
+                text=broken_code,
+            )
+        )
+        await did_save(ls, params)
+        diagnostics = ls.diagnostics.get(uri, [])
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == 1
+        assert diagnostics[0].message == "Syntax Error"
+
+        ls.shutdown()
+        os.remove(temp_file_path)
+
+    @pytest.mark.asyncio
+    async def test_did_change(self):
+        """Test changing a Jac file triggers diagnostics."""
+        code = get_code("")
+        temp_file_path = create_temp_jac_file(code)
+        uri, ls = create_ls_with_workspace(temp_file_path)
+
+        await did_open(ls, DidOpenTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=1,
+                text=code,
+            )
+        ))
+
+        # No error, should be no diagnostics
+        params = DidChangeTextDocumentParams(
+            text_document=VersionedTextDocumentIdentifier(uri=uri, version=2),
+            content_changes=[{"text": "\n" + code}]
+        )
+        ls.workspace.put_text_document(TextDocumentItem(
+            uri=uri,
+            language_id="jac",
+            version=2,
+            text="\n" + code,
+        ))
+        await did_change(ls, params)
+        diagnostics = ls.diagnostics.get(uri, [])
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == 0
+
+        # Now add a syntax error and update workspace
+        # This should trigger diagnostics with a syntax error
+        error_code = "\nerror"
+        params = DidChangeTextDocumentParams(
+            text_document=VersionedTextDocumentIdentifier(uri=uri, version=3),
+            content_changes=[{"text": error_code + code}]
+        )
+        ls.workspace.put_text_document(TextDocumentItem(
+            uri=uri,
+            language_id="jac",
+            version=3,
+            text=error_code + code,
+        ))
+        await did_change(ls, params)
+        diagnostics = ls.diagnostics.get(uri, [])
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == 1
+        assert diagnostics[0].message == "Syntax Error"
+
+        ls.shutdown()
+        os.remove(temp_file_path)
+
+    def test_vsce_formatting(self):
+        """Test formatting a Jac file returns edits."""
+        code = get_code("")
+        temp_file_path = create_temp_jac_file(code)
+        uri, ls = create_ls_with_workspace(temp_file_path)
+        params = DocumentFormattingParams(
+            text_document=TextDocumentIdentifier(uri=uri),
+            options={"tabSize": 4, "insertSpaces": True}
+        )
+        edits = formatting(ls, params)
+        assert isinstance(edits, list)
+        assert isinstance(edits[0], TextEdit)
+        assert len(edits[0].new_text) > 100  # it is a random number to check if the text is changed
+        print(edits[0].new_text)
+        ls.shutdown()
+        os.remove(temp_file_path)

jaclang/langserve/tests/server_test/utils.py

@@ -0,0 +1,115 @@
+"""Unit test utilities for JacLangServer."""
+import os
+import tempfile
+
+from jaclang.langserve.engine import JacLangServer
+from jaclang.vendor.pygls.uris import from_fs_path
+from jaclang.vendor.pygls.workspace import Workspace
+
+from textwrap import dedent
+
+def get_jac_file_path():
+    """Return the absolute path to the sample Jac file used for testing."""
+    return os.path.abspath(
+        os.path.join(os.path.dirname(__file__), "../../../../examples/manual_code/circle.jac")
+    )
+
+def create_temp_jac_file(initial_content: str = "") -> str:
+    """Create a temporary Jac file with optional initial content and return its path."""
+    temp = tempfile.NamedTemporaryFile(delete=False, suffix=".jac", mode="w", encoding="utf-8")
+    temp.write(initial_content)
+    temp.close()
+    return temp.name
+
+def get_code(code: str) -> str:
+    """Generate a sample Jac code snippet with optional test code injected."""
+    jac_code = dedent(f'''
+    """
+    This module demonstrates a simple circle class and a function to calculate
+    the area of a circle in all of Jac's glory.
+    """
+
+    import math;
+
+    # Module-level global variable
+    glob RAD = 5;
+
+    """Function to calculate the area of a circle."""
+    def calculate_area(radius: float) -> float {{
+        return math.pi * radius * radius;
+    }}
+
+    #* (This is a multiline comment in Jac)
+    Above we have the demonstration of a function to calculate the area of a circle.
+    Below we have the demonstration of a class to calculate the area of a circle.
+    *#
+
+    """Enum for shape types"""
+    enum ShapeType {{
+        CIRCLE = "Circle",
+        UNKNOWN = "Unknown"
+    }}
+
+    """Base class for a shape."""
+    obj Shape {{
+        has shape_type: ShapeType;
+
+        """Abstract method to calculate the area of a shape."""
+        def area -> float abs;
+    }}
+
+    """Circle class inherits from Shape."""
+    obj Circle(Shape) {{
+        def init(radius: float) {{
+            super.init(ShapeType.CIRCLE);
+            self.radius = radius;
+        }}
+
+        """Overridden method to calculate the area of the circle."""
+        override def area -> float {{
+            return math.pi * self.radius * self.radius;
+        }}
+    }}
+
+    with entry {{
+        c = Circle(RAD);
+    }}
+
+    # Global also works here
+
+    with entry:__main__ {{
+        # To run the program functionality
+        print(
+            f"Area of a circle with radius {{RAD}} using function: {{calculate_area(RAD)}}"
+        );
+        print(
+            f"Area of a {{c.shape_type.value}} with radius {{RAD}} using class: {{c.area()}}"
+        );
+    }}
+
+    # Unit Tests!
+    glob expected_area = 78.53981633974483;
+    {code}
+
+    test calc_area {{
+        check almostEqual(calculate_area(RAD), expected_area);
+    }}
+
+    test circle_area {{
+        c = Circle(RAD);
+        check almostEqual(c.area(), expected_area);
+    }}
+
+    test circle_type {{
+        c = Circle(RAD);
+        check c.shape_type == ShapeType.CIRCLE;
+    }}
+''')
+    return jac_code
+
+def create_ls_with_workspace(file_path: str):
+    """Create JacLangServer and workspace for a given file path, return (uri, ls)."""
+    ls = JacLangServer()
+    uri = from_fs_path(file_path)
+    ls.lsp._workspace = Workspace(os.path.dirname(file_path), ls)
+    return uri, ls

jaclang/langserve/tests/test_sem_tokens.py

@@ -23,7 +23,7 @@ class TestUpdateSemTokens(TestCase):
 
         self.document_lines = [
             "",
-            "import:py math;",
+            "import math;",
             "",
             '"""Function to calculate the area of a circle."""',
             "can calculate_area(radius: float) -> float {",
@@ -264,7 +264,7 @@ class TestUpdateSemTokens(TestCase):
         )
         self.document_lines = [
             "",
-            "import:py math;",
+            "import math;",
             "",
             '"""Function to calculate the area of a circle."""',
             "can calculate_area(radius::= a + a // 2) > 5 {",

jaclang/langserve/tests/test_server.py

@@ -5,6 +5,7 @@ from jaclang.langserve.engine import JacLangServer
 from .session import LspSession
 
 import lsprotocol.types as lspt
+import pytest
 
 
 class TestJacLangServer(TestCase):
@@ -59,7 +60,8 @@ class TestJacLangServer(TestCase):
         lsp.deep_check(circle_impl_file)
         pos = lspt.Position(8, 11)
         self.assertIn(
-            "ability) calculate_area: float",
+            # "ability) calculate_area: float",
+            "ability) calculate_area\n( radius : float ) -> float",
             lsp.get_hover_info(circle_impl_file, pos).contents.value,
         )
 
@@ -76,10 +78,12 @@ class TestJacLangServer(TestCase):
         lsp.deep_check(circle_impl_file)
         pos = lspt.Position(8, 11)
         self.assertIn(
-            "ability) calculate_area: float",
+            # "ability) calculate_area: float",
+            "(public ability) calculate_area\n( radius : float ) -> float",
             lsp.get_hover_info(circle_impl_file, pos).contents.value,
         )
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_show_type_impl(self) -> None:
         """Test that the server doesn't run if there is a syntax error."""
         lsp = JacLangServer()
@@ -114,7 +118,7 @@ class TestJacLangServer(TestCase):
         circle_file = uris.from_fs_path(self.fixture_abs_path("circle_pure.jac"))
         lsp.deep_check(circle_file)
         self.assertIn(
-            "fixtures/circle_pure.impl.jac:8:0-8:19",
+            "fixtures/circle_pure.impl.jac:8:5-8:19",
             str(lsp.get_definition(circle_file, lspt.Position(9, 16))),
         )
         self.assertIn(
@@ -144,23 +148,22 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         decldef_file = uris.from_fs_path(
-            self.examples_abs_path("micro/decl_defs_impl.jac")
+            self.examples_abs_path("micro/decl_defs_main.impl.jac")
         )
         lsp.deep_check(decldef_file)
-        self.assertNotIn(
-            "decl_defs_main.jac:8:8-8:17",
-            str(lsp.get_definition(decldef_file, lspt.Position(2, 24))),
-        )
         decldef_main_file = uris.from_fs_path(
             self.examples_abs_path("micro/decl_defs_main.jac")
         )
         lsp.deep_check(decldef_main_file)
         lsp.deep_check(decldef_file)
         self.assertIn(
-            "decl_defs_main.jac:8:8-8:17",
-            str(lsp.get_definition(decldef_file, lspt.Position(2, 24))),
+            "decl_defs_main.jac:7:8-7:17",
+            str(lsp.get_definition(decldef_file, lspt.Position(2, 20))),
         )
 
+    @pytest.mark.xfail(
+        reason="TODO: Fix the go to definition for imports[ abs_path is not set]"
+    )
     def test_test_annex(self) -> None:
         """Test that the server doesn't run if there is a syntax error."""
         lsp = JacLangServer()
@@ -176,6 +179,9 @@ class TestJacLangServer(TestCase):
             lsp.get_hover_info(circle_file, pos).contents.value,
         )
 
+    @pytest.mark.xfail(
+        reason="TODO: Fix the go to definition for imports[ abs_path is not set]"
+    )
     def test_go_to_defintion_import(self) -> None:
         """Test that the go to definition is correct."""
         lsp = JacLangServer()
@@ -205,6 +211,9 @@ class TestJacLangServer(TestCase):
                     str(lsp.get_definition(import_file, lspt.Position(line, char))),
                 )
 
+    @pytest.mark.xfail(
+        reason="TODO: Fix the go to definition for imports[ abs_path is not set]"
+    )
     def test_go_to_definition_foolme(self) -> None:
         """Test that the go to definition is correct."""
         lsp = JacLangServer()
@@ -237,6 +246,7 @@ class TestJacLangServer(TestCase):
                     str(lsp.get_definition(import_file, lspt.Position(line, char))),
                 )
 
+    @pytest.mark.xfail(reason="TODO: Fix the go to definition")
     def test_go_to_definition_index_expr(self) -> None:
         """Test that the go to definition is correct."""
         lsp = JacLangServer()
@@ -261,6 +271,7 @@ class TestJacLangServer(TestCase):
                     str(lsp.get_definition(import_file, lspt.Position(line, char))),
                 )
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_sem_tokens(self) -> None:
         """Test that the Semantic Tokens are generated correctly."""
         lsp = JacLangServer()
@@ -295,6 +306,7 @@ class TestJacLangServer(TestCase):
         for token_type, expected_count in expected_counts:
             self.assertEqual(str(sem_list).count(token_type), expected_count)
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_completion(self) -> None:
         """Test that the completions are correct."""
         lsp = JacLangServer()
@@ -369,7 +381,7 @@ class TestJacLangServer(TestCase):
             (
                 lspt.Position(37, 12),
                 ["self", "add", "subtract", "x", "Colorenum", "Colour1", "red", "r"],
-                160,
+                153,
                 None,
             ),
         ]
@@ -411,6 +423,7 @@ class TestJacLangServer(TestCase):
             for expected in expected_refs:
                 self.assertIn(expected, references)
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_py_type__definition(self) -> None:
         """Test that the go to definition is correct for pythoon imports."""
         lsp = JacLangServer()
@@ -429,9 +442,10 @@ class TestJacLangServer(TestCase):
             (20, 45, "pygame_mock/color.py:0:0-2:4"),
             (19, 77, "mock/constants.py:4:3-4:15"),
             (26, 28, "mock/display.py:0:0-1:7"),
-            (24, 22, "/argparse.pyi:124:0-249:13"),
+            (24, 22, "vendor/mypy/typeshed/stdlib/argparse.pyi:125:0-256:13"),
             (19, 74, "pygame_mock/constants.py:4:3-4:15"),
-            (27, 17, "/stdlib/os/__init__.pyi:50:0-50:3"),
+            # TODO: Need to properly support this
+            # (27, 17, "/stdlib/os/__init__.pyi:50:0-50:3"),
         ]
 
         for line, char, expected in positions:
@@ -439,8 +453,10 @@ class TestJacLangServer(TestCase):
                 self.assertIn(
                     expected,
                     str(lsp.get_definition(import_file, lspt.Position(line, char))),
+                    msg=positions.index((line, char, expected)) + 1,
                 )
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_py_type__references(self) -> None:
         """Test that the go to definition is correct for pythoon imports."""
         lsp = JacLangServer()
@@ -491,8 +507,8 @@ class TestJacLangServer(TestCase):
                 [
                     "24:42-24:56",
                     "24:16-24:30",
-                    "argparse.pyi:334:21-334:35",
-                    "argparse.pyi:163:29-163:43",
+                    "argparse.pyi:358:21-358:35",
+                    "argparse.pyi:164:29-164:43",
                     "argparse.pyi:32:52-32:66",
                 ],
             ),
@@ -502,6 +518,7 @@ class TestJacLangServer(TestCase):
             for expected in expected_refs:
                 self.assertIn(expected, references)
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_rename_symbol(self) -> None:
         """Test that the rename is correct."""
         lsp = JacLangServer()
@@ -533,6 +550,7 @@ class TestJacLangServer(TestCase):
             for expected in expected_refs:
                 self.assertIn(expected, references)
 
+    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_rename_uses(self) -> None:
         """Test that the rename is correct."""
         lsp = JacLangServer()
@@ -545,19 +563,19 @@ class TestJacLangServer(TestCase):
         # fmt: off
         test_cases = [
             (0, 7, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
-            (4, 6, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
-            (25, 7, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
+            (4, 8, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
+            (25, 6, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
             (10, 10, "canBar", "27:8-27:11", "10:8-10:11"),
             (27, 9, "canBar", "27:8-27:11", "10:8-10:11"),
             (9, 6, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
             (26, 11, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
-            (16, 7, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
+            (16, 8, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
             (28, 6, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
-            (11, 10, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
-            (16, 14, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
-            (28, 13, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
-            (12, 10, "canBaz", "12:8-12:11", "20:13-20:16"),
-            (20, 14, "canBaz", "12:8-12:11", "20:13-20:16"),
+            (11, 10, "canBar", "11:8-11:11", "16:9-16:12", "28:11-28:14"),
+            (16, 12, "canBar", "11:8-11:11", "16:9-16:12", "28:11-28:14"),
+            (28, 13, "canBar", "11:8-11:11", "16:9-16:12", "28:11-28:14"),
+            (12, 10, "canBaz", "12:8-12:11", "20:9-20:12"),
+            (20, 12, "canBaz", "12:8-12:11", "20:9-20:12"),
             (26, 6, "count", "27:4-27:7", "26:4-26:7"),
             (27, 5, "count", "27:4-27:7", "26:4-26:7"),
         ]