def test_find_definition_same_basename(workspace, libspec_manager, cases,
tmpdir):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.find_definition import find_definition
workspace.set_root("case_same_basename", libspec_manager=libspec_manager)
doc1 = workspace.get_doc("tasks1.robot")
doc2 = workspace.get_doc("directory/tasks2.robot")
completion_context = CompletionContext(doc1, workspace=workspace.ws)
def1 = find_definition(completion_context)
completion_context = CompletionContext(doc2, workspace=workspace.ws)
def2 = find_definition(completion_context)
assert len(def1) == 1
assert len(def2) == 1
assert (def1[0].source.replace(
"\\", "/").endswith("case_same_basename/my_library.py"))
assert (def2[0].source.replace(
"\\", "/").endswith("case_same_basename/directory/my_library.py"))
found = [
lib_info for lib_info in libspec_manager.iter_lib_info()
if lib_info.library_doc.name == "my_library"
]
assert len(found) == 2
def test_section_completions(data_regression):
from robotframework_ls.impl import section_completions
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.robot_workspace import RobotDocument
from robotframework_ls.config.config import Config
config = Config(root_uri="", init_opts={}, process_id=-1, capabilities={})
config.update(
{"robot": {
"completions": {
"section_headers": {
"form": "both"
}
}
}})
doc = RobotDocument("unused", source="""**""")
completions = section_completions.complete(
CompletionContext(doc, config=config))
data_regression.check(completions, basename="header_completions_all")
doc = RobotDocument("unused", source="""**settin""")
completions = section_completions.complete(
CompletionContext(doc, config=config))
data_regression.check(completions,
basename="header_completions_filter_settings")
config.update({})
doc = RobotDocument("unused", source="""**""")
completions = section_completions.complete(
CompletionContext(doc, config=config))
data_regression.check(completions,
basename="header_completions_all_plural")
def test_completion_with_auto_import_resource_import(workspace,
setup_case2_in_dir_doc):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import auto_import_completions
from robocorp_ls_core.basic import wait_for_condition
doc = workspace.get_doc("case1.robot")
doc.source = """
*** Keywords ***
KeywordInCase1
In Lib 2
"""
doc2 = setup_case2_in_dir_doc
doc2.source = """
*** Test Cases ***
User can call library
KeywordInCa"""
wait_for_condition(lambda: len(
auto_import_completions.complete(
CompletionContext(doc2, workspace=workspace.ws), {})) == 1)
completions = auto_import_completions.complete(
CompletionContext(doc2, workspace=workspace.ws), {})
assert len(completions) == 1
apply_completion(doc2, completions[0])
assert (doc2.source == """*** Settings ***
Resource ../case1.robot
*** Test Cases ***
User can call library
KeywordInCase1""")
def test_keyword_completions_library_prefix(
workspace, libspec_manager, data_regression
):
from robotframework_ls.impl import keyword_completions
from robotframework_ls.impl.completion_context import CompletionContext
workspace.set_root("case4", libspec_manager=libspec_manager)
doc = workspace.get_doc("case4.robot")
doc.source = """*** Settings ***
Library String
Library Collections
Resource case4resource.txt
*** Test Cases ***
Test
case4resource3."""
completions = keyword_completions.complete(
CompletionContext(doc, workspace=workspace.ws)
)
data_regression.check(
completions, basename="test_keyword_completions_library_prefix_1"
)
doc.source = """*** Settings ***
Library String
Library Collections
Resource case4resource.txt
*** Test Cases ***
Test
case4resource3.Another"""
completions = keyword_completions.complete(
CompletionContext(doc, workspace=workspace.ws)
)
data_regression.check(
completions, basename="test_keyword_completions_library_prefix_2"
)
doc.source = """*** Settings ***
Library Collections
*** Test Cases ***
Test
Collections.Append To Lis"""
completions = keyword_completions.complete(
CompletionContext(doc, workspace=workspace.ws)
)
assert [completion["label"] for completion in completions] == ["Append To List"]
def test_completion_with_auto_import_duplicated(workspace,
setup_case2_in_dir_doc):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import auto_import_completions
from robotframework_ls.impl.protocols import IKeywordFound
from robotframework_ls.impl.collect_keywords import (
collect_keyword_name_to_keyword_found, )
from robocorp_ls_core.lsp import TextDocumentItem
doc = workspace.get_doc("case1.robot")
doc.source = """
*** Keywords ***
KeywordInCase1
In Lib 2
"""
# Just create a dummy entry for KeywordInCase1.
doc_foobar = workspace.ws.put_document(
TextDocumentItem(
"foobar",
text="""
*** Keywords ***
KeywordInCase1
In Lib 2
""",
))
keyword_name_to_keyword_found: Dict[
str, List[IKeywordFound]] = collect_keyword_name_to_keyword_found(
CompletionContext(doc_foobar, workspace=workspace.ws))
doc2 = setup_case2_in_dir_doc
doc2.source = """
*** Test Cases ***
User can call library
KeywordInCa"""
completions = auto_import_completions.complete(
CompletionContext(doc2, workspace=workspace.ws),
keyword_name_to_keyword_found)
assert len(completions) == 1
apply_completion(doc2, completions[0])
assert (doc2.source == """*** Settings ***
Resource ../case1.robot
*** Test Cases ***
User can call library
case1.KeywordInCase1""")
def threaded_monaco_completions_from_code_full(
self,
prefix: str,
full_code: str,
position: PositionTypedDict,
uri: str,
indent: str,
monitor: Optional[IMonitor] = None,
):
from robotframework_ls.impl.robot_workspace import RobotDocument
from robotframework_ls.impl.completion_context import CompletionContext
from robocorp_ls_core.workspace import Document
from robotframework_ls.impl import section_completions
from robotframework_ls.impl import snippets_completions
from robotframework_ls.server_api.monaco_conversions import (
convert_to_monaco_completion,
)
from robotframework_ls.impl.completion_context import CompletionType
d = Document(uri, prefix)
last_line, _last_col = d.get_last_line_col()
line = last_line + position["line"]
col = position["character"]
col += len(indent)
document = RobotDocument(uri, full_code)
completion_context = CompletionContext(
document,
line,
col,
config=self.config,
monitor=monitor,
workspace=self.workspace,
)
completion_context.type = CompletionType.shell
completions = self._complete_from_completion_context(completion_context)
completions.extend(section_completions.complete(completion_context))
completions.extend(snippets_completions.complete(completion_context))
return {
"suggestions": [
convert_to_monaco_completion(
c, line_delta=last_line, col_delta=len(indent), uri=uri
)
for c in completions
]
}
def test_keyword_completions_resource_does_not_exist(workspace,
libspec_manager,
data_regression):
from robotframework_ls.robot_config import RobotConfig
from robotframework_ls.impl import keyword_completions
from robotframework_ls.impl.completion_context import CompletionContext
workspace.set_root("case4", libspec_manager=libspec_manager)
doc = workspace.get_doc("case4.robot")
doc.source = """*** Settings ***
Library DoesNotExist
Library .
Library ..
Library ../
Resource does_not_exist.txt
Resource ${foo}/does_not_exist.txt
Resource ../does_not_exist.txt
Resource .
Resource ..
Resource ../
Resource ../../does_not_exist.txt
Resource case4resource.txt
*** Test Cases ***
Test
case4resource3."""
config = RobotConfig()
completions = keyword_completions.complete(
CompletionContext(doc, workspace=workspace.ws, config=config))
data_regression.check(completions)
def test_keyword_completions_format(workspace, libspec_manager):
from robotframework_ls.impl import keyword_completions
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.robot_config import RobotConfig
from robotframework_ls.impl.robot_lsp_constants import (
OPTION_ROBOT_COMPLETION_KEYWORDS_FORMAT,
OPTION_ROBOT_COMPLETION_KEYWORDS_FORMAT_FIRST_UPPER,
)
workspace.set_root("case1", libspec_manager=libspec_manager)
doc = workspace.get_doc("case1.robot")
doc.source = doc.source + "\n should be"
config = RobotConfig()
config.update({
OPTION_ROBOT_COMPLETION_KEYWORDS_FORMAT:
OPTION_ROBOT_COMPLETION_KEYWORDS_FORMAT_FIRST_UPPER
})
assert (config.get_setting(
OPTION_ROBOT_COMPLETION_KEYWORDS_FORMAT, str,
"") == OPTION_ROBOT_COMPLETION_KEYWORDS_FORMAT_FIRST_UPPER)
completions = keyword_completions.complete(
CompletionContext(doc, workspace=workspace.ws, config=config))
assert sorted([comp["label"] for comp in completions]) == [
"Length should be",
"Should be empty",
"Should be equal",
"Should be equal as integers",
"Should be equal as numbers",
"Should be equal as strings",
"Should be true",
]
def test_keyword_completions_from_resource_files(data_regression, workspace,
tmpdir, cases,
libspec_manager):
from robotframework_ls.impl import keyword_completions
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.robot_lsp_constants import OPTION_ROBOT_VARIABLES
from robotframework_ls.robot_config import RobotConfig
config = RobotConfig()
config.update(
{"robot": {
"variables": {
"ext_folder": cases.get_path("ext")
}
}})
assert config.get_setting(OPTION_ROBOT_VARIABLES, dict, {}) == {
"ext_folder": cases.get_path("ext")
}
workspace.set_root(cases.get_path("case3"),
libspec_manager=libspec_manager)
doc = workspace.get_doc("case3.robot")
doc.source = doc.source + "\n equal redef"
completions = keyword_completions.complete(
CompletionContext(doc, workspace=workspace.ws, config=config))
data_regression.check(completions,
basename="keyword_completions_from_resource_files")
def test_completion_with_auto_import_case1_library_imported_3(
workspace, setup_case2_in_dir_doc):
from robotframework_ls.impl import auto_import_completions
from robotframework_ls.impl.completion_context import CompletionContext
doc = setup_case2_in_dir_doc
# Get completions from the user library adding the existing *** Settings ***
doc.source = """*** Settings ***
*** Test Cases ***
User can call library
Verify another m"""
# Needed to pre-generate the information
workspace.ws.libspec_manager.get_library_info(
libname="case1_library",
create=True,
current_doc_uri=workspace.get_doc("case1.robot").uri,
)
completions = auto_import_completions.complete(
CompletionContext(doc, workspace=workspace.ws), {})
assert len(completions) == 1
apply_completion(doc, completions[0])
assert (doc.source == """*** Settings ***
Library ../case1_library.py
*** Test Cases ***
User can call library
Verify Another Model""")
def test_keyword_completions_builtin_after_space_before_newline(
workspace, libspec_manager):
from robotframework_ls.impl import keyword_completions
from robotframework_ls.impl.completion_context import CompletionContext
workspace.set_root("case1", libspec_manager=libspec_manager)
doc = workspace.get_doc("case1.robot")
doc.source = doc.source + "\n should be \n"
line, _col = doc.get_last_line_col()
line_contents = doc.get_line(line - 1)
completions = keyword_completions.complete(
CompletionContext(doc,
workspace=workspace.ws,
line=line - 1,
col=len(line_contents)))
assert sorted([comp["label"] for comp in completions]) == [
"Length Should Be",
"Should Be Empty",
"Should Be Equal",
"Should Be Equal As Integers",
"Should Be Equal As Numbers",
"Should Be Equal As Strings",
"Should Be True",
]
def test_keyword_completions_directory_separator(workspace, libspec_manager,
use_config, separator):
from robotframework_ls.impl import keyword_completions
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.robot_config import RobotConfig
import sys
if sys.platform != "win32" and separator == "\\":
return
workspace.set_root("case_inner_keywords", libspec_manager=libspec_manager)
doc = workspace.get_doc("case_root.robot")
doc.source = f"""
*** Settings ***
Resource inner{separator}case_inner.robot
*** Test Cases ***
Testing Completion Here
Check with ke"""
if use_config:
config = RobotConfig()
else:
config = None
completions = keyword_completions.complete(
CompletionContext(doc, workspace=workspace.ws, config=config))
assert sorted([comp["label"] for comp in completions
]) == ["Check with keyword at inner"]
def test_resource_completions_resolve_var(data_regression, workspace, cases,
libspec_manager, workspace_dir):
from robotframework_ls.impl import filesystem_section_completions
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.robot_lsp_constants import OPTION_ROBOT_VARIABLES
from robotframework_ls.robot_config import RobotConfig
cases.copy_to("case4", workspace_dir)
config = RobotConfig()
config.update(
{"robot": {
"variables": {
"ext_folder": cases.get_path("ext")
}
}})
assert config.get_setting(OPTION_ROBOT_VARIABLES, dict, {}) == {
"ext_folder": cases.get_path("ext")
}
workspace.set_root(workspace_dir, libspec_manager=libspec_manager)
doc = workspace.get_doc("case4.robot")
doc.source = """*** Settings ***
Resource ${ext_folder}/"""
completions = filesystem_section_completions.complete(
CompletionContext(doc, workspace=workspace.ws, config=config))
data_regression.check(completions)
def test_find_definition_keyword_resource_in_pythonpath(
workspace, libspec_manager, cases):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.find_definition import find_definition
from robotframework_ls.robot_config import RobotConfig
from robotframework_ls.impl.robot_lsp_constants import OPTION_ROBOT_PYTHONPATH
case2_path = cases.get_path("case2")
config = RobotConfig()
config.update({"robot": {"pythonpath": [case2_path]}})
assert config.get_setting(OPTION_ROBOT_PYTHONPATH, list,
[]) == [case2_path]
libspec_manager.config = config
workspace.set_root("case1", libspec_manager=libspec_manager)
doc = workspace.get_doc("case1.robot")
doc.source = """
*** Settings ***
Resource case2.robot"""
completion_context = CompletionContext(doc,
workspace=workspace.ws,
config=config)
definitions = find_definition(completion_context)
assert len(definitions) == 1, "Failed to find definition"
definition = next(iter(definitions))
assert definition.source.endswith("case2.robot")
assert definition.lineno == 0
def test_find_definition_should_not_resolve_link_in_resource(
workspace, libspec_manager, cases, tmpdir):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.find_definition import find_definition
target_original, target_link = create_case_as_link(cases, tmpdir, "case4")
workspace.set_absolute_path_root(target_link,
libspec_manager=libspec_manager)
doc = workspace.get_doc("case4.robot")
doc.source = """*** Settings ***
Library String
Library Collections
Resource case4resource.txt
*** Test Cases ***
Test
case4resource3.Yet Another Equal Redefined"""
completion_context = CompletionContext(doc, workspace=workspace.ws)
definitions = find_definition(completion_context)
assert len(definitions) == 1
definition = next(iter(definitions))
assert definition.source.endswith("case4resource3.robot")
assert definition.lineno == 1
check_using_link_version(definition.source, target_link, target_original)
def test_folding_range_basic(workspace, libspec_manager, data_regression):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.folding_range import folding_range
workspace.set_root("case4", libspec_manager=libspec_manager)
doc = workspace.get_doc("case4.robot")
doc.source += """
*** Test Cases ***
Log It
Log
Log
Log It 2
Log
Log
Log It 3
Log
Log
FOR ${element} IN @{LIST}
Log ${element}
END
Nothing here
"""
completion_context = CompletionContext(doc, workspace=workspace.ws)
data_regression.check(folding_range(completion_context))
def test_string_variables_completions_unable_to_tokenize_2(
workspace, libspec_manager, data_regression):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import variable_completions
workspace.set_root("case1", libspec_manager=libspec_manager)
doc = workspace.get_doc("case1.robot")
doc.source = """
*** Variables ***
${NAME} Robot Framework
${VERSION} 2.0
${ROBOT} = ${NAME} ${VERSION}
*** Test Cases ***
List Variable
Log ${NAME}
Should Contain ${na ${na}"""
line, col = doc.get_last_line_col()
completions = variable_completions.complete(
CompletionContext(doc,
workspace=workspace.ws,
line=line,
col=col - len(" ${na}")))
data_regression.check(completions)
def test_completion_with_auto_import_import_not_duplicated_case1_library(
workspace, cases, libspec_manager, workspace_dir):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import auto_import_completions
cases.copy_to("case1", workspace_dir)
workspace.set_root(workspace_dir, libspec_manager=libspec_manager)
doc = workspace.get_doc("case1.robot")
doc.source = """
*** Settings ***
Library case1_library
*** Test Cases ***
User can call library
Verify another m"""
# Needed to pre-generate the information
workspace.ws.libspec_manager.get_library_info(
libname="case1_library",
create=True,
current_doc_uri=workspace.get_doc("case1.robot").uri,
)
completions = auto_import_completions.complete(
CompletionContext(doc, workspace=workspace.ws), {})
assert len(completions) == 0
def test_complete_from_context(rf_server_api, libspec_manager, tmpdir):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.robot_workspace import RobotDocument
from robotframework_ls.impl.robot_workspace import RobotWorkspace
from robocorp_ls_core.watchdog_wrapper import create_observer
api = rf_server_api
text = """*** Task ***
Some task
Log Something console=True
Lo"""
doc = RobotDocument("", text)
line, col = doc.get_last_line_col()
workspace = RobotWorkspace(
str(tmpdir),
fs_observer=create_observer("dummy", []),
libspec_manager=libspec_manager,
)
completion_context = CompletionContext(doc, line, col, workspace=workspace)
for completion in api._complete_from_completion_context(completion_context):
if completion["label"] == "Log":
break
else:
raise AssertionError('Did not find "Log" entry in completions.')
def test_completion_with_auto_import_import_not_duplicated_stdlib(
workspace, cases, libspec_manager, workspace_dir):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import auto_import_completions
cases.copy_to("case1", workspace_dir)
workspace.set_root(workspace_dir, libspec_manager=libspec_manager)
doc = workspace.get_doc("case1.robot")
doc.source = """
*** Settings ***
Library case1_library.py
Library Collections
*** Test Cases ***
User can call library
Copy Diction"""
completions = auto_import_completions.complete(
CompletionContext(doc, workspace=workspace.ws), {})
# As the Collections library is already there, don't show that completion here
# (it's already managed in other completions).
assert len(completions) == 0
def test_keyword_completions_respect_pythonpath(workspace, cases,
libspec_manager,
data_regression):
from robotframework_ls.impl import keyword_completions
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.robot_config import RobotConfig
from robotframework_ls.impl.robot_lsp_constants import OPTION_ROBOT_PYTHONPATH
case4_path = cases.get_path("case4")
# Note how we are accessing case4resource.txt while the workspace is set for case3.
config = RobotConfig()
config.update({"robot": {"pythonpath": [case4_path]}})
assert config.get_setting(OPTION_ROBOT_PYTHONPATH, list,
[]) == [case4_path]
libspec_manager.config = config
workspace.set_root(cases.get_path("case3"),
libspec_manager=libspec_manager)
doc = workspace.get_doc("case3.robot")
doc.source = """*** Settings ***
Resource case4resource.txt
*** Test Cases ***
Can use resource keywords
[Documentation] Checks that we can have a resource
... including another resource.
My Equal Redefined 2 2
Yet Another Equ"""
completions = keyword_completions.complete(
CompletionContext(doc, workspace=workspace.ws, config=config))
data_regression.check(completions)
def _create_completion_context(
self, doc_uri, line, col, monitor: Optional[IMonitor]
):
from robotframework_ls.impl.completion_context import CompletionContext
if not self._check_min_version((3, 2)):
log.info("robotframework version too old.")
return None
workspace = self.workspace
if not workspace:
log.info("Workspace still not initialized.")
return None
document = workspace.get_document(doc_uri, accept_from_file=True)
if document is None:
log.info("Unable to get document for uri: %s.", doc_uri)
return None
return CompletionContext(
document,
line,
col,
workspace=workspace,
config=self.config,
monitor=monitor,
)
def test_typing_not_shown(libspec_manager, workspace, data_regression,
workspace_dir):
from robocorp_ls_core import uris
from os.path import os
from robotframework_ls_tests.fixtures import LIBSPEC_3
from robotframework_ls.impl import keyword_completions
from robotframework_ls.impl.completion_context import CompletionContext
from robocorp_ls_core.lsp import TextDocumentItem
workspace_dir_a = os.path.join(workspace_dir, "workspace_dir_a")
os.makedirs(workspace_dir_a)
with open(os.path.join(workspace_dir_a, "my.libspec"), "w") as stream:
stream.write(LIBSPEC_3)
libspec_manager.add_workspace_folder(uris.from_fs_path(workspace_dir_a))
assert libspec_manager.get_library_info("case3_library",
create=False) is not None
workspace.set_root(workspace_dir, libspec_manager=libspec_manager)
doc = workspace.ws.put_document(TextDocumentItem("temp_doc.robot",
text=""))
doc.source = """*** Settings ***
Library case3_library
*** Test Cases ***
Can use resource keywords
Case Verify"""
completions = keyword_completions.complete(
CompletionContext(doc, workspace=workspace.ws))
data_regression.check(completions)
def test_semantic_highlighting_arguments(workspace):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.semantic_tokens import semantic_tokens_full
workspace.set_root("case1")
doc = workspace.get_doc("case1.robot")
doc.source = """
*** Test Cases ***
Some Test
Clear All Highlights formatter=some ${arg1} other
""".replace("\r\n", "\n").replace("\r", "\n")
context = CompletionContext(doc, workspace=workspace.ws)
semantic_tokens = semantic_tokens_full(context)
check(
(semantic_tokens, doc),
[
("*** Test Cases ***", "header"),
("Some Test", "testCaseName"),
("Clear All Highlights", "keywordNameCall"),
("formatter", "parameterName"),
("=", "variableOperator"),
("some ", "argumentValue"),
("${", "variableOperator"),
("arg1", "variable"),
("}", "variableOperator"),
(" other", "argumentValue"),
],
)
def test_code_lens_run_basic(workspace, libspec_manager, data_regression):
from robotframework_ls_tests.fixtures import check_code_lens_data_regression
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.code_lens import code_lens_runs
from robotframework_ls.impl.code_lens import code_lens_resolve
workspace.set_root("case4", libspec_manager=libspec_manager)
doc = workspace.get_doc("case4.robot")
doc.source = """
*** Test Cases ***
Some Test
[Documentation] Docs
*** Task ***
Some Task
[Documentation] Docs
"""
completion_context = CompletionContext(doc, workspace=workspace.ws)
found = code_lens_runs(completion_context)
check_code_lens_data_regression(data_regression, found)
for c in found:
# i.e.: don't change anything here
assert code_lens_resolve(completion_context, c) == c
def test_find_definition_variables_dict(workspace, libspec_manager,
data_regression):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.find_definition import find_definition
workspace.set_root("case4", libspec_manager=libspec_manager)
doc = workspace.get_doc("case4.robot")
doc.source = """
*** Variables ***
@{SOME LIST} foo bar baz
&{SOME DICT} string=cat int=${1} list=@{SOME LIST}
*** Test Cases ***
Log Global Constants
Log ${SOME LIST} info
Log ${SOME DICT} info"""
line, col = doc.get_last_line_col()
col -= len("CT} info")
completion_context = CompletionContext(doc,
workspace=workspace.ws,
line=line,
col=col)
data_regression.check(
_definitions_to_data_regression(find_definition(completion_context)))
def test_library_completions_in_dirs(data_regression, workspace, cases,
libspec_manager, workspace_dir):
from robotframework_ls.impl import filesystem_section_completions
from robotframework_ls.impl.completion_context import CompletionContext
import os.path
cases.copy_to("case1", workspace_dir)
workspace.set_root(workspace_dir, libspec_manager=libspec_manager)
doc = workspace.get_doc("case1.robot")
doc.source = """*** Settings ***
Library dir1/caseXXX"""
dir1 = os.path.join(workspace_dir, "dir1")
os.mkdir(dir1)
mycase_py = os.path.join(dir1, "mycase.py")
with open(mycase_py, "w") as stream:
stream.write("""def my_method():\n pass""")
line, col = doc.get_last_line_col()
completions = filesystem_section_completions.complete(
CompletionContext(doc,
workspace=workspace.ws,
line=line,
col=col - len("XXX")))
data_regression.check(completions)
def test_completion_with_auto_import_basic_stdlib(workspace, cases,
libspec_manager,
workspace_dir):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import auto_import_completions
cases.copy_to("case1", workspace_dir)
workspace.set_root(workspace_dir, libspec_manager=libspec_manager)
doc = workspace.get_doc("case1.robot")
doc.source = """
*** Settings ***
Library case1_library
*** Test Cases ***
User can call library
Copy Diction"""
completions = auto_import_completions.complete(
CompletionContext(doc, workspace=workspace.ws), {})
assert len(completions) == 1
apply_completion(doc, completions[0])
assert (doc.source == """
*** Settings ***
Library case1_library
Library Collections
*** Test Cases ***
User can call library
Copy Dictionary""")
def test_keyword_completions_template(workspace, libspec_manager):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import keyword_completions
workspace.set_root("case2", libspec_manager=libspec_manager)
doc = workspace.get_doc("case2.robot")
doc.source = """
*** Keywords ***
My Equal Redefined
[Arguments] ${arg1} ${arg2}
Should Be Equal ${arg1} ${arg2}
*** Settings ***
Test Template my eq"""
completions = keyword_completions.complete(
CompletionContext(doc, workspace=workspace.ws)
)
found = [
completion["label"]
for completion in completions
if completion["label"].lower() == "my equal redefined"
]
assert len(found) == 1
def test_semantic_highlighting_keyword(workspace):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl.semantic_tokens import semantic_tokens_full
workspace.set_root("case1")
doc = workspace.get_doc("case1.robot")
doc.source = """*** Keywords ***
Some Keyword
[Arguments] ${arg1}
Call Keyword ${arg1}
""".replace("\r\n", "\n").replace("\r", "\n")
context = CompletionContext(doc, workspace=workspace.ws)
semantic_tokens = semantic_tokens_full(context)
check(
(semantic_tokens, doc),
[
("*** Keywords ***", "header"),
("Some Keyword", "keywordNameDefinition"),
("[", "variableOperator"),
("Arguments", "setting"),
("]", "variableOperator"),
("${", "variableOperator"),
("arg1", "variable"),
("}", "variableOperator"),
("Call Keyword", "keywordNameCall"),
("${", "variableOperator"),
("arg1", "variable"),
("}", "variableOperator"),
],
)