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_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_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_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_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_completion_with_auto_handle_unparseable_error(workspace,
setup_case2_in_dir_doc,
workspace_dir):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import auto_import_completions
import os.path
from robocorp_ls_core.basic import wait_for_condition
doc = workspace.get_doc("case1.robot")
doc.source = """/invalid/file/here ustehous usneothu snteuha usoentuho"""
os.makedirs(os.path.join(workspace_dir, "in_dir"), exist_ok=True)
with open(os.path.join(workspace_dir, "in_dir", "case3.robot"),
"w") as stream:
stream.write("""
*** Keywords ***
KeywordInCase1
In Lib 2""")
doc2 = setup_case2_in_dir_doc
doc2.source = """
*** Test Cases ***
User can call library
KeywordInCa"""
# i.e.: make sure that our in-memory folders are in sync.
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 case3.robot
*** Test Cases ***
User can call library
KeywordInCase1""")
def test_completion_not_duplicated(workspace, cases, libspec_manager, workspace_dir):
from robocorp_ls_core.lsp import TextDocumentItem
import os.path
from robocorp_ls_core import uris
from robotframework_ls.robot_config import RobotConfig
from robotframework_ls.impl.collect_keywords import (
collect_keyword_name_to_keyword_found,
)
from robotframework_ls.impl.protocols import IKeywordFound
cases.copy_to("case_inner_keywords", workspace_dir)
workspace.set_root(workspace_dir, libspec_manager=libspec_manager)
config = RobotConfig()
config.update({"robot.pythonpath": [workspace_dir]})
libspec_manager.config = config
uri = uris.from_fs_path(os.path.join(workspace_dir, "inner", "case_inner.robot"))
workspace.ws.put_document(
TextDocumentItem(
uri,
text="""*** Settings ***
Resource case_root.robot
*** Keywords ***
Check with keyword at inner
[Arguments] ${arg1} ${arg2}
Should Be Equal ${arg1} ${arg2}
*** Test Cases ***
Testing Completion Here
Check with ke""",
)
)
doc = workspace.ws.get_document(uri, accept_from_file=False)
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import auto_import_completions
workspace.ws.wait_for_check_done(5)
context = CompletionContext(doc, workspace=workspace.ws, config=config)
keyword_name_to_keyword_found: Dict[
str, List[IKeywordFound]
] = collect_keyword_name_to_keyword_found(context)
completions = auto_import_completions.complete(
context, keyword_name_to_keyword_found
)
# I.e.: all the related symbols are already imported and will be shown
# in the regular completion.
assert len(completions) == 0
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 test_no_reserved_keywords(workspace, setup_case2_in_dir_doc):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import auto_import_completions
doc = workspace.get_doc("case1.robot")
doc.source = """
*** Keywords ***
KeywordInCase1
Else i"""
completions = auto_import_completions.complete(
CompletionContext(doc, workspace=workspace.ws), {})
for completion in completions:
assert completion["label"] != "Else If (Reserved)"
def _threaded_complete_all(self, doc_uri, line, col, monitor: IMonitor):
from robotframework_ls.impl import section_name_completions
from robotframework_ls.impl import keyword_completions
from robotframework_ls.impl import variable_completions
from robotframework_ls.impl import filesystem_section_completions
from robotframework_ls.impl import keyword_parameter_completions
from robotframework_ls.impl import auto_import_completions
from robotframework_ls.impl.collect_keywords import (
collect_keyword_name_to_keyword_found,
)
from robotframework_ls.impl import ast_utils
completion_context = self._create_completion_context(
doc_uri, line, col, monitor
)
if completion_context is None:
return []
ret = section_name_completions.complete(completion_context)
if not ret:
ret.extend(filesystem_section_completions.complete(completion_context))
if not ret:
token_info = completion_context.get_current_token()
if token_info is not None:
token = ast_utils.get_keyword_name_token(
token_info.node, token_info.token
)
if token is not None:
keyword_name_to_keyword_found: Dict[
str, List[IKeywordFound]
] = collect_keyword_name_to_keyword_found(completion_context)
ret.extend(keyword_completions.complete(completion_context))
ret.extend(
auto_import_completions.complete(
completion_context, keyword_name_to_keyword_found
)
)
return ret
if not ret:
ret.extend(variable_completions.complete(completion_context))
if not ret:
ret.extend(keyword_parameter_completions.complete(completion_context))
return ret
def _complete_from_completion_context(self, completion_context):
from robotframework_ls.impl import section_name_completions
from robotframework_ls.impl import keyword_completions
from robotframework_ls.impl import variable_completions
from robotframework_ls.impl import dictionary_completions
from robotframework_ls.impl import filesystem_section_completions
from robotframework_ls.impl import keyword_parameter_completions
from robotframework_ls.impl import auto_import_completions
from robotframework_ls.impl.collect_keywords import (
collect_keyword_name_to_keyword_found,
)
from robotframework_ls.impl import ast_utils
ret = section_name_completions.complete(completion_context)
if not ret:
ret.extend(filesystem_section_completions.complete(completion_context))
if not ret:
token_info = completion_context.get_current_token()
if token_info is not None:
token = ast_utils.get_keyword_name_token(
token_info.node, token_info.token
)
if token is not None:
keyword_name_to_keyword_found: Dict[
str, List[IKeywordFound]
] = collect_keyword_name_to_keyword_found(completion_context)
ret.extend(keyword_completions.complete(completion_context))
ret.extend(
auto_import_completions.complete(
completion_context, keyword_name_to_keyword_found
)
)
return ret
if not ret:
ret.extend(variable_completions.complete(completion_context))
if not ret:
ret.extend(dictionary_completions.complete(completion_context))
if not ret:
ret.extend(keyword_parameter_completions.complete(completion_context))
return ret
def test_completion_with_auto_import_keyword_format(workspace, cases,
libspec_manager,
workspace_dir):
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import auto_import_completions
from robotframework_ls.robot_config import RobotConfig
from robotframework_ls.impl.robot_lsp_constants import (
OPTION_ROBOT_COMPLETION_KEYWORDS_FORMAT, )
cases.copy_to("case1", workspace_dir)
config = RobotConfig()
# Check that although the options are presented with case, the comparison
# internally is case-insensitive.
config.update({OPTION_ROBOT_COMPLETION_KEYWORDS_FORMAT: "AlL lowEr"})
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, config=config), {})
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""")
