robotframework-okw-web-selenium 0.3.0__py3-none-any.whl

okw_web_selenium/__init__.py

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

okw_web_selenium/adapters/selenium_web.py

@@ -0,0 +1,209 @@
+from SeleniumLibrary import SeleniumLibrary
+from robot.libraries.BuiltIn import BuiltIn
+
+class SeleniumWebAdapter:
+
+    def __init__(self, browser):
+        self.browser = browser
+        self.sl = SeleniumLibrary()
+        self.sl.open_browser("about:blank", browser=self.browser)
+
+
+    def go_to(self, url):
+        self.sl.go_to(url)
+
+    def maximize_window(self):
+        self.sl.maximize_browser_window()
+
+    def input_text(self, locator, value):
+        resolved = self._resolve(locator)
+        self.sl.input_text(resolved, value)
+
+    def click(self, locator):
+        resolved = self._resolve(locator)
+        self.sl.click_element(resolved)
+
+    def double_click(self, locator):
+        resolved = self._resolve(locator)
+        self.sl.double_click_element(resolved)
+
+    def get_text(self, locator):
+        resolved = self._resolve(locator)
+        return self.sl.get_text(resolved)
+
+    def get_value(self, locator):
+        resolved = self._resolve(locator)
+        return self.sl.get_value(resolved)
+
+    def get_attribute(self, locator, name):
+        resolved = self._resolve(locator)
+        el = self.sl.get_webelement(resolved)
+        return el.get_attribute(name)
+
+    def clear_text(self, locator):
+        resolved = self._resolve(locator)
+        self.sl.clear_element_text(resolved)
+
+    def element_exists(self, locator):
+        try:
+            self.sl.get_webelement(self._resolve(locator))
+            return True
+        except Exception:
+            return False
+
+    def select_by_label(self, locator, label):
+        resolved = self._resolve(locator)
+        self.sl.select_from_list_by_label(resolved, label)
+
+    def select_by_value(self, locator, value):
+        resolved = self._resolve(locator)
+        self.sl.select_from_list_by_value(resolved, value)
+
+    def select_by_index(self, locator, index):
+        resolved = self._resolve(locator)
+        self.sl.select_from_list_by_index(resolved, str(index))
+
+    def press_keys(self, locator, keys):
+        target = self._resolve(locator) if locator else None
+        self.sl.press_keys(target, keys)
+
+    def wait_until_visible(self, locator, timeout=None):
+        resolved = self._resolve(locator)
+        self.sl.wait_until_element_is_visible(resolved, timeout=timeout)
+
+    def wait_until_not_visible(self, locator, timeout=None):
+        resolved = self._resolve(locator)
+        self.sl.wait_until_element_is_not_visible(resolved, timeout=timeout)
+
+    def set_checkbox(self, locator, checked: bool):
+        el = self.sl.get_webelement(self._resolve(locator))
+        if bool(el.is_selected()) != bool(checked):
+            el.click()
+
+    def is_checkbox_selected(self, locator) -> bool:
+        el = self.sl.get_webelement(self._resolve(locator))
+        return bool(el.is_selected())
+
+    def get_selected_list_labels(self, locator):
+        resolved = self._resolve(locator)
+        return self.sl.get_selected_list_labels(resolved)
+
+    def get_selected_list_values(self, locator):
+        resolved = self._resolve(locator)
+        return self.sl.get_selected_list_values(resolved)
+
+    def scroll_into_view(self, locator):
+        el = self.sl.get_webelement(self._resolve(locator))
+        try:
+            self.sl.driver.execute_script('arguments[0].scrollIntoView({block: "center", inline: "nearest"});', el)
+        except Exception:
+            pass
+
+    def is_enabled(self, locator) -> bool:
+        try:
+            el = self.sl.get_webelement(self._resolve(locator))
+            return bool(el.is_enabled())
+        except Exception:
+            return False
+
+    def is_editable(self, locator) -> bool:
+        try:
+            el = self.sl.get_webelement(self._resolve(locator))
+            if not el.is_enabled():
+                return False
+            tag = (el.tag_name or '').lower()
+            ce = (el.get_attribute('contenteditable') or '').lower()
+            if ce in ('true', 'plaintext-only'):
+                return True
+            ro = el.get_attribute('readonly')
+            if ro is not None and str(ro).lower() not in ('false', 'none'):
+                return False
+            if tag in ('input', 'textarea'):
+                return True
+            return False
+        except Exception:
+            return False
+
+    def is_visible(self, locator) -> bool:
+        try:
+            el = self.sl.get_webelement(self._resolve(locator))
+            return bool(el.is_displayed())
+        except Exception:
+            return False
+
+    def is_focusable(self, locator) -> bool:
+        try:
+            el = self.sl.get_webelement(self._resolve(locator))
+            if not el.is_enabled():
+                return False
+            tag = (el.tag_name or '').lower()
+            ce = (el.get_attribute('contenteditable') or '').lower()
+            if ce in ('true', 'plaintext-only'):
+                return True
+            tb = el.get_attribute('tabindex')
+            if tb is not None:
+                try:
+                    if int(str(tb)) >= 0:
+                        return True
+                except Exception:
+                    pass
+            if tag in ('input', 'select', 'textarea', 'button'):
+                return True
+            if tag == 'a':
+                href = el.get_attribute('href')
+                if href:
+                    return True
+            return False
+        except Exception:
+            return False
+
+    def is_clickable(self, locator) -> bool:
+        try:
+            return bool(self.is_visible(locator) and self.is_enabled(locator))
+        except Exception:
+            return False
+
+    def unselect_all_from_list(self, locator):
+        resolved = self._resolve(locator)
+        self.sl.unselect_all_from_list(resolved)
+
+    def unselect_from_list_by_label(self, locator, labels):
+        resolved = self._resolve(locator)
+        self.sl.unselect_from_list_by_label(resolved, labels)
+
+    def unselect_from_list_by_value(self, locator, values):
+        resolved = self._resolve(locator)
+        self.sl.unselect_from_list_by_value(resolved, values)
+
+    def select_radio(self, group_name: str, value: str):
+        self.sl.select_radio_button(group_name, value)
+
+    def radio_button_should_be_set_to(self, group_name: str, value: str):
+        self.sl.radio_button_should_be_set_to(group_name, value)
+
+    def _resolve(self, locator_dict):
+        if not locator_dict:
+            raise ValueError("Locator missing")
+        if isinstance(locator_dict, str):
+            return locator_dict
+        if isinstance(locator_dict, dict):
+            if len(locator_dict) != 1:
+                raise ValueError(f"Locator must have exactly one key, got: {locator_dict}")
+            key, value = list(locator_dict.items())[0]
+            return f"{key}:{value}"
+        raise TypeError(f"Unsupported locator format: {locator_dict}")
+
+    def focus(self, locator):
+        el = self.sl.get_webelement(self._resolve(locator))
+        try:
+            self.sl.driver.execute_script('arguments[0].focus();', el)
+        except Exception:
+            el.click()
+
+    def has_focus(self, locator) -> bool:
+        el = self.sl.get_webelement(self._resolve(locator))
+        try:
+            active = self.sl.driver.switch_to.active_element
+            return el == active
+        except Exception:
+            return False

okw_web_selenium/keywords/web_keywords.py

@@ -0,0 +1,28 @@
+from robot.api.deco import keyword
+from okw4robot.runtime.context import context
+
+
+class WebKeywords:
+    """Selenium-specific keywords for web automation."""
+
+    @keyword("ExecuteJS")
+    def execute_js(self, script: str):
+        """Executes raw JavaScript in the current browser context.
+
+        Arguments:
+        - ``script``: JavaScript source to execute. Must be a self-contained string.
+
+        Behavior:
+        - Supported with web adapters that expose SeleniumLibrary as ``adapter.sl``.
+          Internally calls ``SeleniumLibrary.Execute Javascript`` and returns its result.
+
+        Examples:
+        | ${title}= | ExecuteJS | return document.title; |
+        | ${len}=   | ExecuteJS | return document.querySelectorAll('input').length; |
+        | ExecuteJS | document.querySelector('#email').value = 'user@example.com'; |
+        """
+        adapter = context.get_adapter()
+        if hasattr(adapter, 'sl') and hasattr(adapter.sl, 'execute_javascript'):
+            return adapter.sl.execute_javascript(script)
+        a = adapter.__class__.__name__
+        raise RuntimeError(f"[ExecuteJS] Not supported by adapter '{a}'")

okw_web_selenium/library.py

@@ -0,0 +1,55 @@
+"""OKW Web Selenium - Selenium driver for OKW4Robot.
+
+Extends OKW4RobotLibrary with Selenium-specific adapter, browser widgets,
+and web-only keywords like ExecuteJS.
+"""
+from __future__ import annotations
+
+from robot.api.deco import library
+
+from okw4robot.library import OKW4RobotLibrary
+from .keywords.web_keywords import WebKeywords
+
+
+@library(scope="GLOBAL")
+class OkwWebSeleniumLibrary(OKW4RobotLibrary, WebKeywords):
+    """Selenium-based GUI test automation with OKW4Robot.
+
+    = Overview =
+
+    ``OkwWebSeleniumLibrary`` extends ``OKW4RobotLibrary`` with Selenium-specific
+    capabilities: a SeleniumWebAdapter for Chrome/Firefox, browser control widgets
+    (URL bar, Maximize Window), and web-only keywords like ``ExecuteJS``.
+
+    All generic OKW4Robot keywords (``SetValue``, ``VerifyValue``, ``ClickOn``, ...)
+    are inherited from the base library.
+
+    = Installation =
+
+    | pip install robotframework-okw-web-selenium
+
+    = Import =
+
+    | Library    okw_web_selenium.library.OkwWebSeleniumLibrary
+
+    = Beispiel =
+
+    | StartHost        Chrome
+    | StartApp         web/LoginApp
+    | SelectWindow     LoginDialog
+    | SetValue         Username    admin
+    | SetValue         Password    secret
+    | ClickOn          OK
+
+    = Abhaengigkeiten =
+
+    - ``robotframework-okw4robot >= 0.4.0``
+    - ``selenium >= 4.0``
+    """
+
+    ROBOT_LIBRARY_DOC_FORMAT = 'ROBOT'
+    ROBOT_LIBRARY_VERSION = '0.3.0'
+
+    def __init__(self):
+        """Initialisiert die OkwWebSeleniumLibrary."""
+        super().__init__()

okw_web_selenium/locators/Chrome.yaml

@@ -0,0 +1,14 @@
+Chrome:
+  __self__:
+    class: okw_web_selenium.adapters.selenium_web.SeleniumWebAdapter
+    browser: chrome
+
+  Chrome:
+
+    URL:
+      class: okw_web_selenium.widgets.host.browsercontrol.UrlBar.UrlBar
+      locator: { virtual: true }
+
+    Maximize Window:
+      class: okw_web_selenium.widgets.host.browsercontrol.BrowserControl
+      locator: { virtual: true }

okw_web_selenium/locators/Firefox.yaml

@@ -0,0 +1,14 @@
+Firefox:
+  __self__:
+    class: okw_web_selenium.adapters.selenium_web.SeleniumWebAdapter
+    browser: firefox
+
+  Firefox:
+
+    URL:
+      class: okw_web_selenium.widgets.host.browsercontrol.UrlBar.UrlBar
+      locator: { virtual: true }
+
+    Maximize Window:
+      class: okw_web_selenium.widgets.host.browsercontrol.BrowserControl
+      locator: { virtual: true }

okw_web_selenium/widgets/__init__.py

@@ -0,0 +1,43 @@
+"""okw_web_selenium.widgets -- Selenium-Web-Widget-Klassen.
+
+Neue WebSe_* Architektur (Delegation):
+    WebSe_Base          -- gemeinsame Selenium-Logik
+    WebSe_TextField     -- input[type=text], input[type=password], ...
+    WebSe_MultilineField -- textarea
+    WebSe_Button        -- button, input[type=submit], ...
+    WebSe_Link          -- a[href]
+    WebSe_Label         -- span, div, p (read-only Text)
+    WebSe_CheckBox      -- input[type=checkbox]
+    WebSe_ComboBox      -- select, editierbare Combos
+    WebSe_RadioList     -- input[type=radio] Gruppen
+    WebSe_ListBox       -- select[multiple]
+    WebSe_Table         -- table
+
+Legacy widgets/common/ Klassen bleiben vorerst erhalten.
+"""
+
+from .webse_base import WebSe_Base
+from .webse_textfield import WebSe_TextField
+from .webse_multilinefield import WebSe_MultilineField
+from .webse_button import WebSe_Button
+from .webse_link import WebSe_Link
+from .webse_label import WebSe_Label
+from .webse_checkbox import WebSe_CheckBox
+from .webse_combobox import WebSe_ComboBox
+from .webse_radiolist import WebSe_RadioList
+from .webse_listbox import WebSe_ListBox
+from .webse_table import WebSe_Table
+
+__all__ = [
+    "WebSe_Base",
+    "WebSe_TextField",
+    "WebSe_MultilineField",
+    "WebSe_Button",
+    "WebSe_Link",
+    "WebSe_Label",
+    "WebSe_CheckBox",
+    "WebSe_ComboBox",
+    "WebSe_RadioList",
+    "WebSe_ListBox",
+    "WebSe_Table",
+]

okw_web_selenium/widgets/host/browsercontrol/BrowserControl.py

@@ -0,0 +1,10 @@
+from okw4robot.widgets.okw_widget import OkwWidget
+
+
+class BrowserControl(OkwWidget):
+
+    def __init__(self, adapter, locator, **options):
+        super().__init__(adapter, locator, **options)
+
+    def okw_click(self):
+        self.adapter.maximize_window()

okw_web_selenium/widgets/host/browsercontrol/UrlBar.py

@@ -0,0 +1,11 @@
+from okw4robot.widgets.okw_widget import OkwWidget
+
+
+class UrlBar(OkwWidget):
+
+    def __init__(self, adapter, locator, **options):
+        super().__init__(adapter, locator, **options)
+
+    def okw_set_value(self, value):
+        self.log_current_method(f"Navigating to: {value}")
+        self.adapter.go_to(value)

okw_web_selenium/widgets/host/browsercontrol/__init__.py

@@ -0,0 +1,2 @@
+from .BrowserControl import BrowserControl
+from .UrlBar import UrlBar

okw_web_selenium/widgets/webse_base.py

@@ -0,0 +1,256 @@
+"""WebSe_Base -- Gemeinsame Basis fuer alle Selenium-Web-Widgets.
+
+Implementiert die ``OkwWidget``-Schnittstelle mit Selenium-spezifischer Logik:
+- Zustandspruefungen (exists, visible, enabled, editable, focus, ...)
+- Attribut-Zugriff (get_attribute, get_text, get_tooltip, get_label, get_placeholder)
+- Sync-Helfer (_wait_before) aus dem alten BaseWidget uebernommen
+"""
+
+import time
+from okw4robot.widgets.okw_widget import OkwWidget
+from robot.libraries.BuiltIn import BuiltIn
+
+
+class WebSe_Base(OkwWidget):
+    """Basis fuer alle Selenium-Web-Widgets."""
+
+    def __init__(self, adapter, locator, **options):
+        super().__init__(adapter, locator, **options)
+        self.sl = adapter.sl  # SeleniumLibrary-Instanz
+
+    # ------------------------------------------------------------------
+    # Interaktion (gemeinsam)
+    # ------------------------------------------------------------------
+    def okw_click(self):
+        self._wait_before('write')
+        self.adapter.click(self.locator)
+
+    def okw_double_click(self):
+        self._wait_before('write')
+        self.adapter.double_click(self.locator)
+
+    def okw_delete(self):
+        """Loescht den Feldinhalt: clear + Backspace-Fallback."""
+        self._wait_before('write')
+        try:
+            self.adapter.clear_text(self.locator)
+        except Exception:
+            pass
+        # Fallback: Ctrl+A + Delete
+        try:
+            self.adapter.press_keys(self.locator, "CTRL+a")
+            self.adapter.press_keys(self.locator, "DELETE")
+        except Exception:
+            pass
+
+    # ------------------------------------------------------------------
+    # Werte lesen (gemeinsam)
+    # ------------------------------------------------------------------
+    def okw_get_text(self) -> str:
+        return self.adapter.get_text(self.locator) or ""
+
+    def okw_get_attribute(self, name: str) -> str:
+        val = self.adapter.get_attribute(self.locator, name)
+        return "" if val is None else str(val)
+
+    def okw_get_tooltip(self) -> str:
+        """Liest Tooltip: bevorzugt 'title', Fallback 'aria-label'."""
+        try:
+            val = self.adapter.get_attribute(self.locator, 'title')
+            if val:
+                return val
+        except Exception:
+            pass
+        try:
+            val = self.adapter.get_attribute(self.locator, 'aria-label')
+            if val:
+                return val
+        except Exception:
+            pass
+        return ""
+
+    def okw_get_label(self) -> str:
+        """Liest Label: aria-labelledby -> label[for] -> aria-label -> sichtbarer Text."""
+        a = self.adapter
+        # 1) aria-labelledby
+        try:
+            aria = a.get_attribute(self.locator, 'aria-labelledby')
+            if aria:
+                parts = [p for p in str(aria).split() if p]
+                texts = []
+                for pid in parts:
+                    try:
+                        texts.append(a.get_text({'id': pid}) or '')
+                    except Exception:
+                        pass
+                joined = ' '.join(t.strip() for t in texts if t is not None)
+                if joined.strip():
+                    return joined
+        except Exception:
+            pass
+        # 2) <label for="id">
+        try:
+            elem_id = a.get_attribute(self.locator, 'id')
+            if elem_id:
+                try:
+                    txt = a.get_text({'css': f'label[for="{elem_id}"]'})
+                    if txt and txt.strip():
+                        return txt
+                except Exception:
+                    pass
+        except Exception:
+            pass
+        # 3) aria-label
+        try:
+            aria_label = a.get_attribute(self.locator, 'aria-label')
+            if aria_label:
+                return aria_label
+        except Exception:
+            pass
+        # 4) Fallback: sichtbarer Text
+        try:
+            return a.get_text(self.locator) or ""
+        except Exception:
+            return ""
+
+    def okw_get_placeholder(self) -> str:
+        try:
+            ph = self.adapter.get_attribute(self.locator, 'placeholder')
+            return ph if ph is not None else ""
+        except Exception:
+            return ""
+
+    # ------------------------------------------------------------------
+    # Zustand (gemeinsam)
+    # ------------------------------------------------------------------
+    def okw_exists(self) -> bool:
+        return self.adapter.element_exists(self.locator)
+
+    def okw_is_visible(self) -> bool:
+        return self.adapter.is_visible(self.locator)
+
+    def okw_is_enabled(self) -> bool:
+        return self.adapter.is_enabled(self.locator)
+
+    def okw_is_editable(self) -> bool:
+        return self.adapter.is_editable(self.locator)
+
+    def okw_has_focus(self) -> bool:
+        return self.adapter.has_focus(self.locator)
+
+    def okw_is_focusable(self) -> bool:
+        return self.adapter.is_focusable(self.locator)
+
+    def okw_is_clickable(self) -> bool:
+        return self.adapter.is_clickable(self.locator)
+
+    def okw_set_focus(self):
+        self.adapter.focus(self.locator)
+
+    # ------------------------------------------------------------------
+    # Sync-Helfer (aus altem BaseWidget uebernommen)
+    # ------------------------------------------------------------------
+    def _get_global_sync(self, intent: str) -> dict:
+        bi = BuiltIn()
+        timeout = bi.get_variable_value(
+            '${OKW_SYNC_TIMEOUT_WRITE}' if intent == 'write' else '${OKW_SYNC_TIMEOUT_READ}',
+            default=10)
+        poll = bi.get_variable_value('${OKW_SYNC_POLL}', default=0.1)
+        scroll_def = bi.get_variable_value('${OKW_SYNC_SCROLL_INTO_VIEW}', default='YES')
+        editable_def = bi.get_variable_value('${OKW_SYNC_CHECK_EDITABLE}', default='YES')
+        busy = bi.get_variable_value(
+            '${OKW_BUSY_SELECTORS_WRITE}' if intent == 'write' else '${OKW_BUSY_SELECTORS_READ}',
+            default=None)
+        busy_list = []
+        if busy:
+            if isinstance(busy, (list, tuple)):
+                busy_list = list(busy)
+            else:
+                busy_list = [v.strip() for v in str(busy).split(',') if v.strip()]
+        return {
+            'timeout': float(timeout) if isinstance(timeout, (int, float)) else bi.convert_time(str(timeout)),
+            'poll': float(poll) if isinstance(poll, (int, float)) else bi.convert_time(str(poll)),
+            'exists': True,
+            'visible': True,
+            'enabled': True,
+            'editable': (
+                self.__class__.__name__ in ('WebSe_TextField', 'WebSe_MultilineField')
+                and str(editable_def).strip().upper() in ('YES', 'TRUE', '1')
+            ) if intent == 'write' else False,
+            'scroll_into_view': (
+                str(scroll_def).strip().upper() in ('YES', 'TRUE', '1')
+            ) if intent == 'write' else False,
+            'until_not_visible': busy_list,
+        }
+
+    def _merge_wait(self, intent: str) -> dict:
+        cfg = self._get_global_sync(intent)
+        inst = (self.options.get('wait') or {}).get(intent, {})
+        for k, v in inst.items():
+            cfg[k] = v
+        return cfg
+
+    def _wait_before(self, intent: str):
+        cfg = self._merge_wait(intent)
+        timeout = float(cfg.get('timeout', 10))
+        poll = float(cfg.get('poll', 0.1))
+        end = time.time() + timeout
+        has_locator = bool(self.locator)
+
+        if has_locator:
+            # 1) exists
+            if cfg.get('exists', True):
+                ok = False
+                while time.time() < end:
+                    if self.adapter.element_exists(self.locator):
+                        ok = True
+                        break
+                    time.sleep(poll)
+                if not ok:
+                    raise AssertionError('[Sync] Element does not exist')
+
+            # 2) scroll into view
+            if cfg.get('scroll_into_view', False):
+                try:
+                    self.adapter.scroll_into_view(self.locator)
+                except Exception:
+                    pass
+
+            # 3) visible
+            if cfg.get('visible', True):
+                try:
+                    self.adapter.wait_until_visible(self.locator, timeout=timeout)
+                except Exception:
+                    raise AssertionError('[Sync] Element not visible')
+
+            # 4) enabled
+            if cfg.get('enabled', True):
+                ok = False
+                while time.time() < end:
+                    if getattr(self.adapter, 'is_enabled', None) and self.adapter.is_enabled(self.locator):
+                        ok = True
+                        break
+                    time.sleep(poll)
+                if not ok:
+                    raise AssertionError('[Sync] Element not enabled')
+
+            # 5) editable
+            if cfg.get('editable', False):
+                ok = False
+                while time.time() < end:
+                    if getattr(self.adapter, 'is_editable', None) and self.adapter.is_editable(self.locator):
+                        ok = True
+                        break
+                    time.sleep(poll)
+                if not ok:
+                    raise AssertionError('[Sync] Element not editable')
+
+        # 6) project waits (until_not_visible)
+        for sel in cfg.get('until_not_visible', []) or []:
+            try:
+                loc = sel if isinstance(sel, (str, dict)) else str(sel)
+                if isinstance(loc, str) and ':' not in loc:
+                    loc = {'css': loc}
+                self.adapter.wait_until_not_visible(loc, timeout=timeout)
+            except Exception:
+                pass

okw_web_selenium/widgets/webse_button.py

@@ -0,0 +1,11 @@
+"""WebSe_Button -- Selenium-Implementierung fuer Buttons."""
+
+from .webse_base import WebSe_Base
+
+
+class WebSe_Button(WebSe_Base):
+    """Button-Widget. Click und DoubleClick aus WebSe_Base genuegen."""
+
+    def okw_get_value(self) -> str:
+        """Fuer Buttons: sichtbarer Text als 'Value'."""
+        return self.adapter.get_text(self.locator) or ""