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