wehub-resource-sync
c6af9e284a
Tests / catch-all (windows-latest) (push) Has been cancelled
Tests / jvm (macos-latest) (push) Has been cancelled
Tests / jvm (ubuntu-latest) (push) Has been cancelled
Tests / jvm (windows-latest) (push) Has been cancelled
Tests / native (macos-latest) (push) Has been cancelled
Tests / native (ubuntu-latest) (push) Has been cancelled
Tests / native (windows-latest) (push) Has been cancelled
Tests / niche (ubuntu-latest) (push) Has been cancelled
Tests / other-langs (macos-latest) (push) Has been cancelled
Tests / other-langs (ubuntu-latest) (push) Has been cancelled
Tests / other-langs (windows-latest) (push) Has been cancelled
Tests / catch-all (macos-latest) (push) Has been cancelled
Tests / catch-all (ubuntu-latest) (push) Has been cancelled
Docs Build / build (push) Has been cancelled
Docs Build / deploy (push) Has been cancelled
CodeQL Advanced / Analyze (actions) (push) Has been cancelled
CodeQL Advanced / Analyze (javascript-typescript) (push) Has been cancelled
CodeQL Advanced / Analyze (python) (push) Has been cancelled
Codespell / Check for spelling errors (push) Has been cancelled
Build and Push Docker Images / build-and-push (push) Has been cancelled
596 lines
32 KiB
Python
596 lines
32 KiB
Python
import os
|
|
|
|
import pytest
|
|
|
|
from serena.symbol import LanguageServerSymbol
|
|
from solidlsp import SolidLanguageServer
|
|
from solidlsp.language_servers.al_language_server import ALLanguageServer
|
|
from solidlsp.ls_config import Language
|
|
from solidlsp.ls_types import SymbolKind
|
|
from solidlsp.ls_utils import SymbolUtils
|
|
from test.conftest import language_tests_enabled
|
|
from test.solidlsp.conftest import format_symbol_for_assert, has_malformed_name, request_all_symbols
|
|
|
|
pytestmark = [pytest.mark.al, pytest.mark.skipif(not language_tests_enabled(Language.AL), reason="AL tests are disabled")]
|
|
|
|
|
|
class TestExtractALDisplayName:
|
|
"""Tests for the ALLanguageServer._extract_al_display_name method."""
|
|
|
|
def test_table_with_quoted_name(self) -> None:
|
|
"""Test extraction from Table with quoted name."""
|
|
assert ALLanguageServer._extract_al_display_name('Table 50000 "TEST Customer"') == "TEST Customer"
|
|
|
|
def test_page_with_quoted_name(self) -> None:
|
|
"""Test extraction from Page with quoted name."""
|
|
assert ALLanguageServer._extract_al_display_name('Page 50001 "TEST Customer Card"') == "TEST Customer Card"
|
|
|
|
def test_codeunit_unquoted(self) -> None:
|
|
"""Test extraction from Codeunit with unquoted name."""
|
|
assert ALLanguageServer._extract_al_display_name("Codeunit 50000 CustomerMgt") == "CustomerMgt"
|
|
|
|
def test_enum_unquoted(self) -> None:
|
|
"""Test extraction from Enum with unquoted name."""
|
|
assert ALLanguageServer._extract_al_display_name("Enum 50000 CustomerType") == "CustomerType"
|
|
|
|
def test_interface_no_id(self) -> None:
|
|
"""Test extraction from Interface (no ID)."""
|
|
assert ALLanguageServer._extract_al_display_name("Interface IPaymentProcessor") == "IPaymentProcessor"
|
|
|
|
def test_table_extension(self) -> None:
|
|
"""Test extraction from TableExtension."""
|
|
assert ALLanguageServer._extract_al_display_name('TableExtension 50000 "Ext Customer"') == "Ext Customer"
|
|
|
|
def test_page_extension(self) -> None:
|
|
"""Test extraction from PageExtension."""
|
|
assert ALLanguageServer._extract_al_display_name('PageExtension 50000 "My Page Ext"') == "My Page Ext"
|
|
|
|
def test_non_al_object_unchanged(self) -> None:
|
|
"""Test that non-AL-object names pass through unchanged."""
|
|
assert ALLanguageServer._extract_al_display_name("fields") == "fields"
|
|
assert ALLanguageServer._extract_al_display_name("CreateCustomer") == "CreateCustomer"
|
|
assert ALLanguageServer._extract_al_display_name("Name") == "Name"
|
|
|
|
def test_report_with_quoted_name(self) -> None:
|
|
"""Test extraction from Report."""
|
|
assert ALLanguageServer._extract_al_display_name('Report 50000 "Sales Invoice"') == "Sales Invoice"
|
|
|
|
def test_query_unquoted(self) -> None:
|
|
"""Test extraction from Query."""
|
|
assert ALLanguageServer._extract_al_display_name("Query 50000 CustomerQuery") == "CustomerQuery"
|
|
|
|
|
|
@pytest.mark.al
|
|
class TestALLanguageServer:
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_symbol_names_are_normalized(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that AL symbol names are normalized (metadata stripped)."""
|
|
file_path = os.path.join("src", "Tables", "Customer.Table.al")
|
|
symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()
|
|
|
|
_all_symbols, root_symbols = symbols
|
|
customer_table = None
|
|
for sym in root_symbols:
|
|
if sym.get("name") == "TEST Customer":
|
|
customer_table = sym
|
|
break
|
|
|
|
assert customer_table is not None, "Could not find 'TEST Customer' table symbol (name should be normalized)"
|
|
# Name should be just "TEST Customer", not "Table 50000 'TEST Customer'"
|
|
assert customer_table["name"] == "TEST Customer", f"Expected normalized name 'TEST Customer', got '{customer_table['name']}'"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_find_symbol_exact_match(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that find_symbol can match AL symbols by normalized name without substring_matching."""
|
|
file_path = os.path.join("src", "Tables", "Customer.Table.al")
|
|
symbols = language_server.request_document_symbols(file_path)
|
|
|
|
# Find symbols that match 'TEST Customer' using LanguageServerSymbol.find()
|
|
for root in symbols.root_symbols:
|
|
ls_symbol = LanguageServerSymbol(root)
|
|
matches = ls_symbol.find("TEST Customer", substring_matching=False)
|
|
if matches:
|
|
assert len(matches) >= 1, "Should find at least one match for 'TEST Customer'"
|
|
assert matches[0].name == "TEST Customer", f"Expected 'TEST Customer', got '{matches[0].name}'"
|
|
return
|
|
|
|
pytest.fail("Could not find 'TEST Customer' symbol by exact name match")
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_find_codeunit_exact_match(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test finding a codeunit by its normalized name."""
|
|
file_path = os.path.join("src", "Codeunits", "CustomerMgt.Codeunit.al")
|
|
symbols = language_server.request_document_symbols(file_path)
|
|
|
|
for root in symbols.root_symbols:
|
|
ls_symbol = LanguageServerSymbol(root)
|
|
matches = ls_symbol.find("CustomerMgt", substring_matching=False)
|
|
if matches:
|
|
assert len(matches) >= 1
|
|
assert matches[0].name == "CustomerMgt"
|
|
return
|
|
|
|
pytest.fail("Could not find 'CustomerMgt' symbol by exact name match")
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_find_symbol(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that AL Language Server can find symbols in the test repository with normalized names."""
|
|
symbols = language_server.request_full_symbol_tree()
|
|
|
|
# Check for table symbols - names should be normalized (no "Table 50000" prefix)
|
|
assert SymbolUtils.symbol_tree_contains_name(symbols, "TEST Customer"), "TEST Customer table not found in symbol tree"
|
|
|
|
# Check for page symbols
|
|
assert SymbolUtils.symbol_tree_contains_name(symbols, "TEST Customer Card"), "TEST Customer Card page not found in symbol tree"
|
|
assert SymbolUtils.symbol_tree_contains_name(symbols, "TEST Customer List"), "TEST Customer List page not found in symbol tree"
|
|
|
|
# Check for codeunit symbols
|
|
assert SymbolUtils.symbol_tree_contains_name(symbols, "CustomerMgt"), "CustomerMgt codeunit not found in symbol tree"
|
|
assert SymbolUtils.symbol_tree_contains_name(symbols, "PaymentProcessorImpl"), (
|
|
"PaymentProcessorImpl codeunit not found in symbol tree"
|
|
)
|
|
|
|
# Check for enum symbol
|
|
assert SymbolUtils.symbol_tree_contains_name(symbols, "CustomerType"), "CustomerType enum not found in symbol tree"
|
|
|
|
# Check for interface symbol
|
|
assert SymbolUtils.symbol_tree_contains_name(symbols, "IPaymentProcessor"), "IPaymentProcessor interface not found in symbol tree"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_find_table_fields(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that AL Language Server can find fields within a table."""
|
|
file_path = os.path.join("src", "Tables", "Customer.Table.al")
|
|
symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()
|
|
|
|
# AL tables should have their fields as child symbols
|
|
customer_table = None
|
|
_all_symbols, root_symbols = symbols
|
|
for sym in root_symbols:
|
|
if sym.get("name") == "TEST Customer":
|
|
customer_table = sym
|
|
break
|
|
|
|
assert customer_table is not None, "Could not find TEST Customer table symbol"
|
|
|
|
# Check for field symbols (AL nests fields under a "fields" group)
|
|
if "children" in customer_table:
|
|
# Find the fields group
|
|
fields_group = None
|
|
for child in customer_table.get("children", []):
|
|
if child.get("name") == "fields":
|
|
fields_group = child
|
|
break
|
|
|
|
assert fields_group is not None, "Fields group not found in Customer table"
|
|
|
|
# Check actual field names
|
|
if "children" in fields_group:
|
|
field_names = [child.get("name", "") for child in fields_group.get("children", [])]
|
|
assert any("Name" in name for name in field_names), f"Name field not found. Fields: {field_names}"
|
|
assert any("Balance" in name for name in field_names), f"Balance field not found. Fields: {field_names}"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_find_procedures(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that AL Language Server can find procedures in codeunits."""
|
|
file_path = os.path.join("src", "Codeunits", "CustomerMgt.Codeunit.al")
|
|
symbols = language_server.request_document_symbols(file_path).get_all_symbols_and_roots()
|
|
|
|
# Find the codeunit symbol - name should be normalized to 'CustomerMgt'
|
|
codeunit_symbol = None
|
|
_all_symbols, root_symbols = symbols
|
|
for sym in root_symbols:
|
|
if sym.get("name") == "CustomerMgt":
|
|
codeunit_symbol = sym
|
|
break
|
|
|
|
assert codeunit_symbol is not None, "Could not find CustomerMgt codeunit symbol"
|
|
|
|
# Check for procedure symbols (if hierarchical)
|
|
if "children" in codeunit_symbol:
|
|
procedure_names = [child.get("name", "") for child in codeunit_symbol.get("children", [])]
|
|
assert any("CreateCustomer" in name for name in procedure_names), "CreateCustomer procedure not found"
|
|
assert any("TestNoSeries" in name for name in procedure_names), "TestNoSeries procedure not found"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_find_referencing_symbols(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that AL Language Server can find references to symbols."""
|
|
# Find references to the Customer table from the CustomerMgt codeunit
|
|
table_file = os.path.join("src", "Tables", "Customer.Table.al")
|
|
symbols = language_server.request_document_symbols(table_file).get_all_symbols_and_roots()
|
|
|
|
# Find the Customer table symbol (name is normalized)
|
|
customer_symbol = None
|
|
_all_symbols, root_symbols = symbols
|
|
for sym in root_symbols:
|
|
if sym.get("name") == "TEST Customer":
|
|
customer_symbol = sym
|
|
break
|
|
|
|
if customer_symbol and "selectionRange" in customer_symbol:
|
|
sel_start = customer_symbol["selectionRange"]["start"]
|
|
refs = language_server.request_references(table_file, sel_start["line"], sel_start["character"])
|
|
|
|
# The Customer table should be referenced in CustomerMgt.Codeunit.al
|
|
assert any("CustomerMgt.Codeunit.al" in ref.get("relativePath", "") for ref in refs), (
|
|
"Customer table should be referenced in CustomerMgt.Codeunit.al"
|
|
)
|
|
|
|
# It should also be referenced in CustomerCard.Page.al
|
|
assert any("CustomerCard.Page.al" in ref.get("relativePath", "") for ref in refs), (
|
|
"Customer table should be referenced in CustomerCard.Page.al"
|
|
)
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_cross_file_symbols(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that AL Language Server can handle cross-file symbol relationships."""
|
|
# Get all symbols to verify cross-file visibility
|
|
symbols = language_server.request_full_symbol_tree()
|
|
|
|
# Count how many AL object symbols we found (names are now normalized)
|
|
al_object_names = []
|
|
|
|
def collect_symbols(syms: list) -> None:
|
|
for sym in syms:
|
|
if isinstance(sym, dict):
|
|
name = sym.get("name", "")
|
|
# These are normalized names now, so just collect them
|
|
al_object_names.append(name)
|
|
if "children" in sym:
|
|
collect_symbols(sym["children"])
|
|
|
|
collect_symbols(symbols)
|
|
|
|
# We should find expected normalized names
|
|
assert "TEST Customer" in al_object_names, f"TEST Customer not found in: {al_object_names}"
|
|
assert "CustomerMgt" in al_object_names, f"CustomerMgt not found in: {al_object_names}"
|
|
assert "CustomerType" in al_object_names, f"CustomerType not found in: {al_object_names}"
|
|
|
|
|
|
@pytest.mark.al
|
|
class TestALHoverInjection:
|
|
"""Tests for hover injection of original AL object names with type and ID."""
|
|
|
|
def _get_symbol_hover(self, language_server: SolidLanguageServer, file_path: str, symbol_name: str) -> tuple[dict | None, str | None]:
|
|
"""Helper to get hover info for a symbol by name.
|
|
|
|
Returns (hover_info, hover_value) tuple.
|
|
"""
|
|
symbols = language_server.request_document_symbols(file_path)
|
|
for sym in symbols.root_symbols:
|
|
if sym.get("name") == symbol_name:
|
|
sel_range = sym.get("selectionRange", {})
|
|
start = sel_range.get("start", {})
|
|
line = start.get("line", 0)
|
|
char = start.get("character", 0)
|
|
hover = language_server.request_hover(file_path, line, char)
|
|
if hover and "contents" in hover:
|
|
return hover, hover["contents"].get("value", "")
|
|
return hover, None
|
|
return None, None
|
|
|
|
def _get_child_symbol_hover(
|
|
self, language_server: SolidLanguageServer, file_path: str, parent_name: str, child_name_contains: str
|
|
) -> tuple[dict | None, str | None]:
|
|
"""Helper to get hover info for a child symbol.
|
|
|
|
Returns (hover_info, hover_value) tuple.
|
|
"""
|
|
symbols = language_server.request_document_symbols(file_path)
|
|
for sym in symbols.root_symbols:
|
|
if sym.get("name") == parent_name:
|
|
for child in sym.get("children", []):
|
|
if child_name_contains in child.get("name", ""):
|
|
sel_range = child.get("selectionRange", {})
|
|
start = sel_range.get("start", {})
|
|
line = start.get("line", 0)
|
|
char = start.get("character", 0)
|
|
hover = language_server.request_hover(file_path, line, char)
|
|
if hover and "contents" in hover:
|
|
return hover, hover["contents"].get("value", "")
|
|
return hover, None
|
|
return None, None
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_table_injects_full_name(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that hovering over a Table symbol shows the full object name with ID."""
|
|
file_path = os.path.join("src", "Tables", "Customer.Table.al")
|
|
hover, value = self._get_symbol_hover(language_server, file_path, "TEST Customer")
|
|
|
|
assert hover is not None, "Hover should return a result for Table symbol"
|
|
assert value is not None, "Hover should have content"
|
|
assert '**Table 50000 "TEST Customer"**' in value, f"Hover should contain full Table name with ID. Got: {value[:200]}"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_page_injects_full_name(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that hovering over a Page symbol shows the full object name with ID."""
|
|
file_path = os.path.join("src", "Pages", "CustomerCard.Page.al")
|
|
hover, value = self._get_symbol_hover(language_server, file_path, "TEST Customer Card")
|
|
|
|
assert hover is not None, "Hover should return a result for Page symbol"
|
|
assert value is not None, "Hover should have content"
|
|
assert '**Page 50001 "TEST Customer Card"**' in value, f"Hover should contain full Page name with ID. Got: {value[:200]}"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_codeunit_injects_full_name(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that hovering over a Codeunit symbol shows the full object name with ID."""
|
|
file_path = os.path.join("src", "Codeunits", "CustomerMgt.Codeunit.al")
|
|
hover, value = self._get_symbol_hover(language_server, file_path, "CustomerMgt")
|
|
|
|
assert hover is not None, "Hover should return a result for Codeunit symbol"
|
|
assert value is not None, "Hover should have content"
|
|
assert "**Codeunit 50000 CustomerMgt**" in value, f"Hover should contain full Codeunit name with ID. Got: {value[:200]}"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_enum_injects_full_name(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that hovering over an Enum symbol shows the full object name with ID."""
|
|
file_path = os.path.join("src", "Enums", "CustomerType.Enum.al")
|
|
hover, value = self._get_symbol_hover(language_server, file_path, "CustomerType")
|
|
|
|
assert hover is not None, "Hover should return a result for Enum symbol"
|
|
assert value is not None, "Hover should have content"
|
|
assert "**Enum 50000 CustomerType**" in value, f"Hover should contain full Enum name with ID. Got: {value[:200]}"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_interface_injects_full_name(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that hovering over an Interface symbol shows the full object name (no ID for interfaces)."""
|
|
file_path = os.path.join("src", "Interfaces", "IPaymentProcessor.Interface.al")
|
|
hover, value = self._get_symbol_hover(language_server, file_path, "IPaymentProcessor")
|
|
|
|
assert hover is not None, "Hover should return a result for Interface symbol"
|
|
assert value is not None, "Hover should have content"
|
|
assert "**Interface IPaymentProcessor**" in value, f"Hover should contain full Interface name. Got: {value[:200]}"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_procedure_no_injection(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that hovering over a procedure does NOT inject object name (procedures are not normalized)."""
|
|
file_path = os.path.join("src", "Codeunits", "CustomerMgt.Codeunit.al")
|
|
hover, value = self._get_child_symbol_hover(language_server, file_path, "CustomerMgt", "CreateCustomer")
|
|
|
|
assert hover is not None, "Hover should return a result for procedure"
|
|
assert value is not None, "Hover should have content"
|
|
# Procedure hover should NOT start with ** (no injection)
|
|
assert not value.startswith("**"), f"Procedure hover should not have injected name. Got: {value[:200]}"
|
|
# But should contain procedure info
|
|
assert "CreateCustomer" in value, f"Hover should contain procedure name. Got: {value[:200]}"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_field_no_injection(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that hovering over a field does NOT inject object name (fields are not normalized)."""
|
|
file_path = os.path.join("src", "Tables", "Customer.Table.al")
|
|
symbols = language_server.request_document_symbols(file_path)
|
|
|
|
# Navigate to a field: Table -> fields -> specific field
|
|
for sym in symbols.root_symbols:
|
|
if sym.get("name") == "TEST Customer":
|
|
for child in sym.get("children", []):
|
|
if child.get("name") == "fields":
|
|
for field in child.get("children", []):
|
|
if "Name" in field.get("name", ""):
|
|
sel_range = field.get("selectionRange", {})
|
|
start = sel_range.get("start", {})
|
|
line = start.get("line", 0)
|
|
char = start.get("character", 0)
|
|
hover = language_server.request_hover(file_path, line, char)
|
|
|
|
assert hover is not None, "Hover should return a result for field"
|
|
value = hover.get("contents", {}).get("value", "")
|
|
# Field hover should NOT start with ** (no injection)
|
|
assert not value.startswith("**"), f"Field hover should not have injected name. Got: {value[:200]}"
|
|
return
|
|
|
|
pytest.fail("Could not find a field to test hover on")
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_multiple_objects_correct_injection(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that multiple AL objects each get their correct full name injected."""
|
|
test_cases = [
|
|
(os.path.join("src", "Tables", "Customer.Table.al"), "TEST Customer", 'Table 50000 "TEST Customer"'),
|
|
(os.path.join("src", "Codeunits", "CustomerMgt.Codeunit.al"), "CustomerMgt", "Codeunit 50000 CustomerMgt"),
|
|
(os.path.join("src", "Enums", "CustomerType.Enum.al"), "CustomerType", "Enum 50000 CustomerType"),
|
|
]
|
|
|
|
for file_path, symbol_name, expected_full_name in test_cases:
|
|
hover, value = self._get_symbol_hover(language_server, file_path, symbol_name)
|
|
|
|
assert hover is not None, f"Hover should return a result for {symbol_name}"
|
|
assert value is not None, f"Hover should have content for {symbol_name}"
|
|
assert f"**{expected_full_name}**" in value, (
|
|
f"Hover for {symbol_name} should contain '{expected_full_name}'. Got: {value[:200]}"
|
|
)
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_contains_separator_after_injection(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that injected hover has a separator between injected name and original content."""
|
|
file_path = os.path.join("src", "Tables", "Customer.Table.al")
|
|
hover, value = self._get_symbol_hover(language_server, file_path, "TEST Customer")
|
|
|
|
assert hover is not None, "Hover should return a result"
|
|
assert value is not None, "Hover should have content"
|
|
# Should have the separator after the bold name
|
|
assert "---" in value, f"Hover should contain separator. Got: {value[:300]}"
|
|
# The separator should come after the injected name
|
|
bold_end = value.find("**", 2) # Find closing **
|
|
separator_pos = value.find("---")
|
|
assert separator_pos > bold_end, "Separator should come after the injected name"
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_preserves_original_content(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that the original hover content is preserved after the injected name."""
|
|
file_path = os.path.join("src", "Tables", "Customer.Table.al")
|
|
hover, value = self._get_symbol_hover(language_server, file_path, "TEST Customer")
|
|
|
|
assert hover is not None, "Hover should return a result"
|
|
assert value is not None, "Hover should have content"
|
|
# Original AL hover content should still be present (the table structure)
|
|
assert "```al" in value, f"Hover should contain original AL code block. Got: {value[:500]}"
|
|
assert 'Table "TEST Customer"' in value, f"Hover should contain original table definition. Got: {value[:500]}"
|
|
|
|
|
|
@pytest.mark.al
|
|
class TestALPathNormalization:
|
|
"""Tests for path normalization in hover injection cache."""
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_with_forward_slash_path(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that hover injection works with forward slash paths."""
|
|
file_path = "src/Tables/Customer.Table.al"
|
|
symbols = language_server.request_document_symbols(file_path)
|
|
|
|
for sym in symbols.root_symbols:
|
|
if sym.get("name") == "TEST Customer":
|
|
sel_range = sym.get("selectionRange", {})
|
|
start = sel_range.get("start", {})
|
|
line = start.get("line", 0)
|
|
char = start.get("character", 0)
|
|
|
|
hover = language_server.request_hover(file_path, line, char)
|
|
assert hover is not None, "Hover should return a result"
|
|
value = hover.get("contents", {}).get("value", "")
|
|
assert '**Table 50000 "TEST Customer"**' in value, f"Hover should have injection. Got: {value[:200]}"
|
|
return
|
|
|
|
pytest.fail("Could not find TEST Customer symbol")
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_with_backslash_path(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that hover injection works with backslash paths (Windows style)."""
|
|
file_path = "src\\Tables\\Customer.Table.al"
|
|
symbols = language_server.request_document_symbols(file_path)
|
|
|
|
for sym in symbols.root_symbols:
|
|
if sym.get("name") == "TEST Customer":
|
|
sel_range = sym.get("selectionRange", {})
|
|
start = sel_range.get("start", {})
|
|
line = start.get("line", 0)
|
|
char = start.get("character", 0)
|
|
|
|
hover = language_server.request_hover(file_path, line, char)
|
|
assert hover is not None, "Hover should return a result"
|
|
value = hover.get("contents", {}).get("value", "")
|
|
assert '**Table 50000 "TEST Customer"**' in value, f"Hover should have injection. Got: {value[:200]}"
|
|
return
|
|
|
|
pytest.fail("Could not find TEST Customer symbol")
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_with_mixed_path_formats_symbols_backslash_hover_forward(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test hover works when symbols requested with backslash but hover with forward slash."""
|
|
file_path_backslash = "src\\Tables\\Customer.Table.al"
|
|
file_path_forward = "src/Tables/Customer.Table.al"
|
|
|
|
# Request symbols with backslash path
|
|
symbols = language_server.request_document_symbols(file_path_backslash)
|
|
|
|
for sym in symbols.root_symbols:
|
|
if sym.get("name") == "TEST Customer":
|
|
sel_range = sym.get("selectionRange", {})
|
|
start = sel_range.get("start", {})
|
|
line = start.get("line", 0)
|
|
char = start.get("character", 0)
|
|
|
|
# Request hover with forward slash path (different format)
|
|
hover = language_server.request_hover(file_path_forward, line, char)
|
|
assert hover is not None, "Hover should return a result"
|
|
value = hover.get("contents", {}).get("value", "")
|
|
assert '**Table 50000 "TEST Customer"**' in value, (
|
|
f"Hover injection should work with mixed path formats. Got: {value[:200]}"
|
|
)
|
|
return
|
|
|
|
pytest.fail("Could not find TEST Customer symbol")
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_with_mixed_path_formats_symbols_forward_hover_backslash(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test hover works when symbols requested with forward slash but hover with backslash."""
|
|
file_path_forward = "src/Tables/Customer.Table.al"
|
|
file_path_backslash = "src\\Tables\\Customer.Table.al"
|
|
|
|
# Request symbols with forward slash path
|
|
symbols = language_server.request_document_symbols(file_path_forward)
|
|
|
|
for sym in symbols.root_symbols:
|
|
if sym.get("name") == "TEST Customer":
|
|
sel_range = sym.get("selectionRange", {})
|
|
start = sel_range.get("start", {})
|
|
line = start.get("line", 0)
|
|
char = start.get("character", 0)
|
|
|
|
# Request hover with backslash path (different format)
|
|
hover = language_server.request_hover(file_path_backslash, line, char)
|
|
assert hover is not None, "Hover should return a result"
|
|
value = hover.get("contents", {}).get("value", "")
|
|
assert '**Table 50000 "TEST Customer"**' in value, (
|
|
f"Hover injection should work with mixed path formats. Got: {value[:200]}"
|
|
)
|
|
return
|
|
|
|
pytest.fail("Could not find TEST Customer symbol")
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_hover_caching_multiple_files_different_path_formats(self, language_server: SolidLanguageServer) -> None:
|
|
"""Test that hover injection cache works correctly across multiple files with different path formats."""
|
|
test_cases = [
|
|
("src/Tables/Customer.Table.al", "src\\Tables\\Customer.Table.al", "TEST Customer", 'Table 50000 "TEST Customer"'),
|
|
(
|
|
"src\\Codeunits\\CustomerMgt.Codeunit.al",
|
|
"src/Codeunits/CustomerMgt.Codeunit.al",
|
|
"CustomerMgt",
|
|
"Codeunit 50000 CustomerMgt",
|
|
),
|
|
]
|
|
|
|
for symbols_path, hover_path, symbol_name, expected_injection in test_cases:
|
|
# Request symbols with one path format
|
|
symbols = language_server.request_document_symbols(symbols_path)
|
|
|
|
for sym in symbols.root_symbols:
|
|
if sym.get("name") == symbol_name:
|
|
sel_range = sym.get("selectionRange", {})
|
|
start = sel_range.get("start", {})
|
|
line = start.get("line", 0)
|
|
char = start.get("character", 0)
|
|
|
|
# Request hover with different path format
|
|
hover = language_server.request_hover(hover_path, line, char)
|
|
assert hover is not None, f"Hover should return a result for {symbol_name}"
|
|
value = hover.get("contents", {}).get("value", "")
|
|
assert f"**{expected_injection}**" in value, (
|
|
f"Hover for {symbol_name} should have injection with mixed paths. Got: {value[:200]}"
|
|
)
|
|
break
|
|
|
|
@pytest.mark.parametrize("language_server", [Language.AL], indirect=True)
|
|
def test_bare_symbol_names(self, language_server) -> None:
|
|
all_symbols = request_all_symbols(language_server)
|
|
malformed_symbols = []
|
|
for s in all_symbols:
|
|
is_al_display_symbol = (
|
|
s["name"].endswith((".Codeunit", ".Page", ".Table", ".TableExt", ".Enum", ".Interface"))
|
|
or (s["name"].startswith('"') and s["name"].endswith('"'))
|
|
or s["name"].startswith(
|
|
(
|
|
"Enum Name ",
|
|
"Area ",
|
|
"Group ",
|
|
"Field ",
|
|
"Part ",
|
|
"SystemPart ",
|
|
"Repeater ",
|
|
"ActionRef ",
|
|
"Key ",
|
|
"FieldGroup ",
|
|
)
|
|
)
|
|
or ":" in s["name"]
|
|
)
|
|
if not is_al_display_symbol and has_malformed_name(
|
|
s,
|
|
whitespace_allowed=s["kind"] in {SymbolKind.Class, SymbolKind.Struct, SymbolKind.Interface, SymbolKind.Enum},
|
|
):
|
|
malformed_symbols.append(s)
|
|
if malformed_symbols:
|
|
pytest.fail(
|
|
f"Found malformed symbols: {[format_symbol_for_assert(sym) for sym in malformed_symbols]}",
|
|
pytrace=False,
|
|
)
|