def get_robot_version():
try:
import robot
v = str(robot.get_version())
except BaseException:
v = "unknown"
return v
def get_robot_version(cls):
try:
import robot
v = str(robot.get_version())
except:
log.exception("Unable to get robot version.")
v = "unknown"
return v
def install_robot_debugger() -> IRobotDebugger:
"""
Installs the robot debugger and registers it where needed. If a debugger
is currently installed, resets it (in this case, any existing session,
stack trace, breakpoints, etc. are reset).
"""
impl = get_global_robot_debugger()
if impl is None:
# Note: only patches once, afterwards, returns the same instance.
from robotframework_debug_adapter.listeners import DebugListener
from robotframework_debug_adapter.listeners import DebugListenerV2
impl = _RobotDebuggerImpl()
DebugListener.on_start_suite.register(impl.start_suite)
DebugListener.on_end_suite.register(impl.end_suite)
DebugListener.on_start_test.register(impl.start_test)
DebugListener.on_end_test.register(impl.end_test)
use_monkeypatching = True
# Not using monkey-patching would've been nice, but due to:
# https://github.com/robotframework/robotframework/issues/3855
# we can't really use it.
#
# On RobotFramework 3.x and earlier 4.x dev versions, we do some monkey-patching because
# the listener was not able to give linenumbers.
from robot import get_version
version = get_version()
use_monkeypatching = version.startswith("3.") or version.startswith(
"4.0.a")
if False and use_monkeypatching:
# NOT CURRENTLY USED!!
# https://github.com/robotframework/robotframework/issues/3855
#
# i.e.: there's no start/end keyword on V3, so, we can currently
# only get linenumbers on the V2 api.
DebugListenerV2.on_start_keyword.register(impl.start_keyword_v2)
DebugListenerV2.on_end_keyword.register(impl.end_keyword_v2)
else:
try:
_apply_monkeypatching_before_4_b_2(impl)
except ImportError:
_apply_monkeypatching_latest(impl)
set_global_robot_debugger(impl)
else:
impl.reset()
return impl
def install_robot_debugger() -> IRobotDebugger:
"""
Installs the robot debugger and registers it where needed. If a debugger
is currently installed, resets it (in this case, any existing session,
stack trace, breakpoints, etc. are reset).
"""
impl = get_global_robot_debugger()
if impl is None:
# Note: only patches once, afterwards, returns the same instance.
from robotframework_debug_adapter.listeners import DebugListener
from robotframework_debug_adapter.listeners import DebugListenerV2
impl = _RobotDebuggerImpl()
DebugListener.on_start_suite.register(impl.start_suite)
DebugListener.on_end_suite.register(impl.end_suite)
DebugListener.on_start_test.register(impl.start_test)
DebugListener.on_end_test.register(impl.end_test)
# On RobotFramework 3.x and earlier 4.x dev versions, we do some monkey-patching because
# the listener was not able to give linenumbers.
from robot import get_version
version = get_version()
use_monkeypatching = version.startswith("3.") or version.startswith(
"4.0.a")
if not use_monkeypatching:
# 4.0.0 onwards
DebugListenerV2.on_start_keyword.register(impl.start_keyword_v2)
DebugListenerV2.on_end_keyword.register(impl.end_keyword_v2)
else:
# Older versions
try:
_apply_monkeypatching_before_4_b_2(impl)
except ImportError:
_apply_monkeypatching_latest(impl)
set_global_robot_debugger(impl)
else:
impl.reset()
return impl
def check(found, expected):
from robotframework_ls.impl.semantic_tokens import decode_semantic_tokens
from robotframework_ls.impl.completion_context import CompletionContext
from robotframework_ls.impl import ast_utils
import robot
semantic_tokens_as_int: List[int] = found[0]
doc: IDocument = found[1]
decoded = decode_semantic_tokens(semantic_tokens_as_int, doc)
if decoded != expected:
from io import StringIO
stream = StringIO()
ast_utils.print_ast(CompletionContext(doc).get_ast(), stream=stream)
raise AssertionError(
"Expected:\n%s\n\nFound:\n%s\n\nAst:\n%s\n\nRobot: %s %s" %
(expected, decoded, stream.getvalue(), robot.get_version(), robot))
def m_version(self):
if self._version is not None:
return self._version
try:
import robot # noqa
except:
log.exception("Unable to import 'robot'.")
version = "NO_ROBOT"
else:
try:
from robot import get_version
version = get_version(naked=True)
except:
log.exception("Unable to get version.")
version = "N/A" # Too old?
self._version = version
return self._version
def get_internal_libspec_dir(cls):
user_home = os.getenv("ROBOTFRAMEWORK_LS_USER_HOME", None)
if user_home is None:
user_home = os.path.expanduser("~")
pyexe = sys.executable
if not isinstance(pyexe, bytes):
pyexe = pyexe.encode("utf-8")
import hashlib
digest = hashlib.sha256(pyexe).hexdigest()[:8]
try:
import robot
v = str(robot.get_version())
except:
v = "unknown"
return os.path.join(user_home, "robotframework_ls", "libspec",
"%s_%s" % (digest, v))
def get_internal_libspec_dir(cls):
from robotframework_ls import robot_config
home = robot_config.get_robotframework_ls_home()
pyexe = sys.executable
if not isinstance(pyexe, bytes):
pyexe = pyexe.encode("utf-8")
import hashlib
digest = hashlib.sha256(pyexe).hexdigest()[:8]
try:
import robot
v = str(robot.get_version())
except:
v = "unknown"
# Note: _v1: information on the mtime of the libspec sources now available.
return os.path.join(home, "specs", "%s_%s" % (digest, v))
def _get_robot_version(self):
version = robot.get_version().split('.')
def _get_robot_version(self):
version = robot.get_version().split('.')
import pytest
from robot import get_version
from robocorp_ls_core.basic import check_min_version
rf_version = get_version(naked=True)
def test_parse_errors(data_regression):
from robotframework_ls.impl.robot_workspace import RobotDocument
from robotframework_ls.impl.ast_utils import collect_errors
from robotframework_ls.impl import ast_utils
source = """*** Settings ***
Documentation A test suite with a single test for valid login.
...
... This test has a workflow that is created using keywords in
... the imported resource file.
Resource resource.txt
"test"
*** Invalid Invalid Invalid ***
Something
*** Test Cases ***
Valid Login
Open Browser To Login Page
Input Username demo
Input Password mode
Submit Credentials
""".replace("\r\n", "\n").replace("\r", "\n")
context = CompletionContext(doc, workspace=workspace.ws)
semantic_tokens = semantic_tokens_full(context)
check(
(semantic_tokens, doc),
[
("*** Test Case ***", "header"),
("Test Case", "testCaseName"),
("Catenate", "keywordNameCall"),
("FOO", "argumentValue"),
("Check = 22", "argumentValue"),
],
)
@pytest.mark.skipif(robot.get_version().startswith("3."),
reason="Requires RF 4 onwards")
def test_semantic_highlighting_for_if(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
FOR ${element} IN @{LIST}
IF ${random} == ${NUMBER_TO_PASS_ON}
Pass Execution "${random} == ${NUMBER_TO_PASS_ON}"
ELSE IF ${random} > ${NUMBER_TO_PASS_ON}
Log To Console Too high.
ELSE
* use "Run Keyword and Ignore Error" but no return value used warning
* performance issue warning like using sleep
* recursive calling
## W202
* show case duplication warning
## TODO
* show hard coded warning
* unused resource file/library file warning
* show dry-run warning or errors
'''
import sys
import os
import hashlib
from robot.model import SuiteVisitor
from robot import get_version
if get_version() < '2.8.0':
raise RuntimeError('RobotFramework 2.8+ required!')
from robot.api import TestSuiteBuilder, TestSuite
from robot.running.model import TestCase
default_settings = {
'MAX_CASES_IN_ONE_SUITE': 10,
'MIN_CASES_IN_ONE_SUITE': 2,
'MAX_STEPS_IN_ONE_CASE': 10,
'MIN_STEPS_IN_ONE_CASE': 2,
'MAX_STEPS_IN_ONE_KW': 15,
'FORBIDDEN_KEYWORDS': ('Fatal Error', 'Set Global Variable'),
'MANDATORY_TAGS': ('owner', ),
'MAX_ARGUMENTS_IN_ONE_KEYWORD': 5,
'DEPRECATED_KEYWORDS': ('Create File With Encoding', ),
}
"\r", "\n"
)
context = CompletionContext(doc, workspace=workspace.ws)
semantic_tokens = semantic_tokens_full(context)
check(
(semantic_tokens, doc),
[
("*** Comments ***", "header"),
("Comment part 1", "comment"),
("Comment part 2", "comment"),
],
)
@pytest.mark.skipif(
robot.get_version().startswith("3."), reason="Requires RF 4 onwards"
)
def test_semantic_highlighting_for_if(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
FOR ${element} IN @{LIST}
IF ${random} == ${NUMBER_TO_PASS_ON}
Pass Execution "${random} == ${NUMBER_TO_PASS_ON}"
ELSE IF ${random} > ${NUMBER_TO_PASS_ON}
Log To Console Too high.
ELSE
