robotframework-okw4robot 0.4.0__py3-none-any.whl

okw4robot/__init__.py

@@ -0,0 +1,3 @@
+from .library import OKW4RobotLibrary
+
+__all__ = ["OKW4RobotLibrary"]

okw4robot/keywords/app.py

@@ -0,0 +1,37 @@
+from robot.api.deco import keyword
+from ..runtime.context import context
+from ..utils.yaml_loader import load_yaml_with_fallback
+from ..utils.logging_mixin import LoggingMixin
+
+class AppKeywords(LoggingMixin):
+
+    @keyword("StartApp")
+    def start_app(self, name: str):
+        self.log_info(f"Starte App '{name}'...")
+        model = load_yaml_with_fallback(name)
+        app_name = name.rsplit("/", 1)[-1]
+
+        if app_name not in model:
+            self.log_error(f"App name '{app_name}' not found in YAML root.")
+            raise KeyError(f"App name '{app_name}' not found in YAML root")
+
+        app_model = model[app_name]
+        context.set_app(app_name, app_model)
+        self.log_info(f"App '{app_name}' gestartet.")
+
+    @keyword("SelectWindow")
+    def select_window(self, name: str):
+        self.log_info(f"Wähle Fenster/Widget '{name}'...")
+        context.set_window(name)
+        self.log_info(f"Fenster/Widget '{name}' aktiviert.")
+
+    @keyword("StopApp")
+    def stop_app(self):
+        if context._app_model is None:
+            self.log_error("Keine App aktiv – nichts zu stoppen.")
+            raise RuntimeError("Stop App failed: No app is currently active.")
+
+        self.log_info(f"Beende App '{context._app_name}'.")
+        context.stop_app()
+
+    

okw4robot/keywords/attribute_keywords.py

@@ -0,0 +1,54 @@
+from robot.api.deco import keyword
+from robot.api import logger
+from ..utils.okw_helpers import should_ignore, get_robot_timeout, resolve_widget, verify_with_timeout, normalize_var_name
+from okw_contract_utils import MatchMode
+
+
+def _get_attr(w, attr_name: str) -> str:
+    try:
+        val = w.okw_get_attribute(attr_name)
+        return "" if val is None else str(val)
+    except Exception:
+        return ""
+
+
+class AttributeKeywords:
+    @keyword("VerifyAttribute")
+    def verify_attribute(self, name, attribute, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyAttribute] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_ATTRIBUTE}", 10.0)
+        verify_with_timeout(lambda: _get_attr(w, attribute), expected, MatchMode.EXACT, timeout, f"[VerifyAttribute] '{name}'")
+
+    @keyword("VerifyAttributeWCM")
+    def verify_attribute_wcm(self, name, attribute, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyAttributeWCM] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_ATTRIBUTE}", 10.0)
+        verify_with_timeout(lambda: _get_attr(w, attribute), expected, MatchMode.WCM, timeout, f"[VerifyAttributeWCM] '{name}'")
+
+    @keyword("VerifyAttributeREGX")
+    def verify_attribute_regx(self, name, attribute, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyAttributeREGX] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_ATTRIBUTE}", 10.0)
+        verify_with_timeout(lambda: _get_attr(w, attribute), expected, MatchMode.REGX, timeout, f"[VerifyAttributeREGX] '{name}'")
+
+    @keyword("MemorizeAttribute")
+    def memorize_attribute(self, name, attribute, variable):
+        from robot.libraries.BuiltIn import BuiltIn
+        w = resolve_widget(name)
+        value = _get_attr(w, attribute)
+        BuiltIn().set_test_variable(normalize_var_name(variable), value)
+
+    @keyword("LogAttribute")
+    def log_attribute(self, name, attribute):
+        w = resolve_widget(name)
+        value = _get_attr(w, attribute)
+        logger.info(f"[LogAttribute] {value}")

okw4robot/keywords/caption_keywords.py

@@ -0,0 +1,53 @@
+from robot.api.deco import keyword
+from robot.api import logger
+from ..utils.okw_helpers import should_ignore, get_robot_timeout, resolve_widget, verify_with_timeout, normalize_var_name
+from okw_contract_utils import MatchMode
+
+
+def _get_caption(w) -> str:
+    try:
+        return w.okw_get_text() or ""
+    except Exception:
+        return ""
+
+
+class CaptionKeywords:
+    @keyword("VerifyCaption")
+    def verify_caption(self, name, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyCaption] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_CAPTION}", 10.0)
+        verify_with_timeout(lambda: _get_caption(w), expected, MatchMode.EXACT, timeout, f"[VerifyCaption] '{name}'")
+
+    @keyword("VerifyCaptionWCM")
+    def verify_caption_wcm(self, name, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyCaptionWCM] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_CAPTION}", 10.0)
+        verify_with_timeout(lambda: _get_caption(w), expected, MatchMode.WCM, timeout, f"[VerifyCaptionWCM] '{name}'")
+
+    @keyword("VerifyCaptionREGX")
+    def verify_caption_regx(self, name, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyCaptionREGX] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_CAPTION}", 10.0)
+        verify_with_timeout(lambda: _get_caption(w), expected, MatchMode.REGX, timeout, f"[VerifyCaptionREGX] '{name}'")
+
+    @keyword("MemorizeCaption")
+    def memorize_caption(self, name, variable):
+        from robot.libraries.BuiltIn import BuiltIn
+        w = resolve_widget(name)
+        value = _get_caption(w)
+        BuiltIn().set_test_variable(normalize_var_name(variable), value)
+
+    @keyword("LogCaption")
+    def log_caption(self, name):
+        w = resolve_widget(name)
+        value = _get_caption(w)
+        logger.info(f"[LogCaption] {value}")

okw4robot/keywords/host.py

@@ -0,0 +1,35 @@
+from robot.api.deco import keyword
+from ..runtime.context import context
+from ..utils.yaml_loader import load_yaml_with_fallback
+from ..utils.loader import load_class
+from ..utils.logging_mixin import LoggingMixin
+
+
+class HostKeywords(LoggingMixin):
+
+    @keyword("StartHost")
+    def start_host(self, name: str):
+        self.log_info(f"Starte Host '{name}'...")
+        model = load_yaml_with_fallback(name)
+        adapter_cls = load_class(model[name]["__self__"]["class"])
+        adapter_args = {k: v for k, v in model[name]["__self__"].items() if k != "class"}
+        adapter = adapter_cls(**adapter_args)
+        context.set_adapter(adapter)
+        self.log_info(f"Host '{name}' erfolgreich gestartet.")
+
+    @keyword("SelectHost")
+    def select_host(self, name: str):
+        current = context.get_adapter().__class__.__name__
+        self.log_info(f"Prüfe, ob Host '{name}' aktiv ist...")
+        if current.lower() != name.lower():
+            self.log_error(f"Host-Kontextfehler: '{name}' ist nicht aktiv (aktuell: '{current}')")
+            raise RuntimeError(f"Host '{name}' is not active (currently: '{current}')")
+        self.log_info(f"Host '{name}' ist aktiv.")
+
+    @keyword("StopHost")
+    def stop_host(self):
+        self.log_info("Stoppe aktuellen Host...")
+        context.stop_adapter()
+        self.log_info("Host wurde gestoppt.")
+
+    

okw4robot/keywords/label_keywords.py

@@ -0,0 +1,53 @@
+from robot.api.deco import keyword
+from robot.api import logger
+from ..utils.okw_helpers import should_ignore, get_robot_timeout, resolve_widget, verify_with_timeout, normalize_var_name
+from okw_contract_utils import MatchMode
+
+
+def _get_label(w) -> str:
+    try:
+        return w.okw_get_label() or ""
+    except Exception:
+        return ""
+
+
+class LabelKeywords:
+    @keyword("VerifyLabel")
+    def verify_label(self, name, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyLabel] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_LABEL}", 10.0)
+        verify_with_timeout(lambda: _get_label(w), expected, MatchMode.EXACT, timeout, f"[VerifyLabel] '{name}'")
+
+    @keyword("VerifyLabelWCM")
+    def verify_label_wcm(self, name, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyLabelWCM] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_LABEL}", 10.0)
+        verify_with_timeout(lambda: _get_label(w), expected, MatchMode.WCM, timeout, f"[VerifyLabelWCM] '{name}'")
+
+    @keyword("VerifyLabelREGX")
+    def verify_label_regx(self, name, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyLabelREGX] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_LABEL}", 10.0)
+        verify_with_timeout(lambda: _get_label(w), expected, MatchMode.REGX, timeout, f"[VerifyLabelREGX] '{name}'")
+
+    @keyword("MemorizeLabel")
+    def memorize_label(self, name, variable):
+        from robot.libraries.BuiltIn import BuiltIn
+        w = resolve_widget(name)
+        value = _get_label(w)
+        BuiltIn().set_test_variable(normalize_var_name(variable), value)
+
+    @keyword("LogLabel")
+    def log_label(self, name):
+        w = resolve_widget(name)
+        value = _get_label(w)
+        logger.info(f"[LogLabel] {value}")

okw4robot/keywords/list_keywords.py

@@ -0,0 +1,72 @@
+import time
+from robot.api.deco import keyword
+from ..runtime.context import context
+from ..utils.okw_helpers import get_robot_timeout, get_robot_poll, resolve_widget
+
+
+class ListKeywords:
+    @keyword("VerifyListCount")
+    def verify_list_count(self, name: str, expected_count):
+        """Verifies the number of items in a list-like widget.
+
+        Arguments:
+        - ``name``: Logical widget name from the current window (YAML model).
+        - ``expected_count``: Integer expected number of items.
+
+        Behavior:
+        - Resolves the widget and polls ``okw_get_list_count()`` until the count equals the expected.
+        - Timing via ``${OKW_TIMEOUT_VERIFY_LIST}`` (default 2s) and ``${OKW_POLL_VERIFY}`` (default 0.1s).
+
+        Supported widgets (base implementation): ListBox, RadioList, native <select> ComboBox.
+        """
+        try:
+            exp = int(str(expected_count).strip())
+        except Exception:
+            raise ValueError(f"[VerifyListCount] Expected must be integer, got '{expected_count}'")
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_LIST}", 2.0)
+        poll = get_robot_poll()
+        end = time.monotonic() + timeout
+        while time.monotonic() < end:
+            try:
+                got = int(w.okw_get_list_count())
+            except NotImplementedError as e:
+                raise RuntimeError(f"[VerifyListCount] Not supported by widget '{name}': {e}")
+            if got == exp:
+                return
+            time.sleep(poll)
+        got = int(w.okw_get_list_count())
+        raise AssertionError(f"[VerifyListCount] Expected {exp}, got {got}")
+
+    @keyword("VerifySelectedCount")
+    def verify_selected_count(self, name: str, expected_count):
+        """Verifies the number of selected items in a list-like widget.
+
+        Arguments:
+        - ``name``: Logical widget name from the current window (YAML model).
+        - ``expected_count``: Integer expected selected count.
+
+        Behavior:
+        - Resolves the widget and polls ``okw_get_selected_count()`` until the count equals the expected.
+        - Timing via ``${OKW_TIMEOUT_VERIFY_LIST}`` (default 2s) and ``${OKW_POLL_VERIFY}`` (default 0.1s).
+
+        Supported widgets (base implementation): ListBox, RadioList, ComboBox (0/1).
+        """
+        try:
+            exp = int(str(expected_count).strip())
+        except Exception:
+            raise ValueError(f"[VerifySelectedCount] Expected must be integer, got '{expected_count}'")
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_LIST}", 2.0)
+        poll = get_robot_poll()
+        end = time.monotonic() + timeout
+        while time.monotonic() < end:
+            try:
+                got = int(w.okw_get_selected_count())
+            except NotImplementedError as e:
+                raise RuntimeError(f"[VerifySelectedCount] Not supported by widget '{name}': {e}")
+            if got == exp:
+                return
+            time.sleep(poll)
+        got = int(w.okw_get_selected_count())
+        raise AssertionError(f"[VerifySelectedCount] Expected {exp}, got {got}")

okw4robot/keywords/params.py

@@ -0,0 +1,43 @@
+from robot.api.deco import keyword
+
+
+class ParamsKeywords:
+    @keyword("SetOKWParameter")
+    def set_okw_parameter(self, name: str, value):
+        """Sets OKW runtime parameters such as timeouts.
+
+        Supported names (case-insensitive):
+        - TimeOutVerifyValue
+        - TimeOutVerifyTooltip
+        - TimeOutVerifyPlaceholder
+
+        Value may be seconds (number) or Robot time string (e.g. '10s').
+        Scope: suite variable.
+        """
+        mapping = {
+            "TIMEOUTVERIFYVALUE": "${OKW_TIMEOUT_VERIFY_VALUE}",
+            "TIMEOUTVERIFYTOOLTIP": "${OKW_TIMEOUT_VERIFY_TOOLTIP}",
+            "TIMEOUTVERIFYPLACEHOLDER": "${OKW_TIMEOUT_VERIFY_PLACEHOLDER}",
+            "TIMEOUTVERIFYLABEL": "${OKW_TIMEOUT_VERIFY_LABEL}",
+            "TIMEOUTVERIFYCAPTION": "${OKW_TIMEOUT_VERIFY_CAPTION}",
+            "TIMEOUTVERIFYATTRIBUTE": "${OKW_TIMEOUT_VERIFY_ATTRIBUTE}",
+            # New timeouts for state verification
+            "TIMEOUTVERIFYEXIST": "${OKW_TIMEOUT_VERIFY_EXIST}",
+            "TIMEOUTVERIFYVISIBLE": "${OKW_TIMEOUT_VERIFY_VISIBLE}",
+            "TIMEOUTVERIFYENABLED": "${OKW_TIMEOUT_VERIFY_ENABLED}",
+            "TIMEOUTVERIFYEDITABLE": "${OKW_TIMEOUT_VERIFY_EDITABLE}",
+            "TIMEOUTVERIFYFOCUSABLE": "${OKW_TIMEOUT_VERIFY_FOCUSABLE}",
+            "TIMEOUTVERIFYCLICKABLE": "${OKW_TIMEOUT_VERIFY_CLICKABLE}",
+            "TIMEOUTVERIFYFOCUS": "${OKW_TIMEOUT_VERIFY_FOCUS}",
+            # Table verification timeout
+            "TIMEOUTVERIFYTABLE": "${OKW_TIMEOUT_VERIFY_TABLE}",
+            # Poll interval for verify loops
+            "POLLVERIFY": "${OKW_POLL_VERIFY}",
+        }
+        key = str(name or "").strip().upper()
+        if key not in mapping:
+            raise ValueError(f"Unsupported OKW parameter: {name}")
+        var_name = mapping[key]
+        from robot.libraries.BuiltIn import BuiltIn
+        # Keep raw value; readers will convert appropriately
+        BuiltIn().set_suite_variable(var_name, value)

okw4robot/keywords/placeholder_keywords.py

@@ -0,0 +1,53 @@
+from robot.api.deco import keyword
+from robot.api import logger
+from ..utils.okw_helpers import should_ignore, get_robot_timeout, resolve_widget, verify_with_timeout, normalize_var_name
+from okw_contract_utils import MatchMode
+
+
+def _get_placeholder(w) -> str:
+    try:
+        return w.okw_get_placeholder() or ""
+    except Exception:
+        return ""
+
+
+class PlaceholderKeywords:
+    @keyword("VerifyPlaceholder")
+    def verify_placeholder(self, name, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyPlaceholder] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_PLACEHOLDER}", 10.0)
+        verify_with_timeout(lambda: _get_placeholder(w), expected, MatchMode.EXACT, timeout, f"[VerifyPlaceholder] '{name}'")
+
+    @keyword("VerifyPlaceholderWCM")
+    def verify_placeholder_wcm(self, name, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyPlaceholderWCM] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_PLACEHOLDER}", 10.0)
+        verify_with_timeout(lambda: _get_placeholder(w), expected, MatchMode.WCM, timeout, f"[VerifyPlaceholderWCM] '{name}'")
+
+    @keyword("VerifyPlaceholderREGX")
+    def verify_placeholder_regx(self, name, expected):
+        if should_ignore(expected):
+            logger.info(f"[VerifyPlaceholderREGX] '{name}' ignored ($IGNORE)")
+            return
+        w = resolve_widget(name)
+        timeout = get_robot_timeout("${OKW_TIMEOUT_VERIFY_PLACEHOLDER}", 10.0)
+        verify_with_timeout(lambda: _get_placeholder(w), expected, MatchMode.REGX, timeout, f"[VerifyPlaceholderREGX] '{name}'")
+
+    @keyword("MemorizePlaceholder")
+    def memorize_placeholder(self, name, variable):
+        from robot.libraries.BuiltIn import BuiltIn
+        w = resolve_widget(name)
+        value = _get_placeholder(w)
+        BuiltIn().set_test_variable(normalize_var_name(variable), value)
+
+    @keyword("LogPlaceholder")
+    def log_placeholder(self, name):
+        w = resolve_widget(name)
+        value = _get_placeholder(w)
+        logger.info(f"[LogPlaceholder] {value}")