Promium 3.9.0__tar.gz → 3.9.2__tar.gz

{promium-3.9.0 → promium-3.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Promium
-Version: 3.9.0
+Version: 3.9.2
 Summary: Selenium wrapper for testing Web UI
 Author: Denis Korytkin, Nataliia Guieva, Roman Zaporozhets, Vladimir Kritov, Oleh Dykusha
 Project-URL: Home page, https://none

{promium-3.9.0 → promium-3.9.2}/Promium.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Promium
-Version: 3.9.0
+Version: 3.9.2
 Summary: Selenium wrapper for testing Web UI
 Author: Denis Korytkin, Nataliia Guieva, Roman Zaporozhets, Vladimir Kritov, Oleh Dykusha
 Project-URL: Home page, https://none

{promium-3.9.0 → promium-3.9.2}/Promium.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ doc/conf.py
 promium/__init__.py
 promium/_diag.py
 promium/_introspect.py
+promium/_soft_assert_rewrite.py
 promium/assertions.py
 promium/base.py
 promium/browsers.py

promium-3.9.2/promium/_introspect.py

@@ -0,0 +1,94 @@
+"""Formatting helpers for soft_assert error messages."""
+
+import difflib
+import os
+import pprint
+
+
+_NO_COLOR = bool(
+    os.environ.get("NO_COLOR")
+    or os.environ.get("PROMIUM_ASSERTION_PANEL_MONO_COLOR")
+)
+_RED = "" if _NO_COLOR else "\033[31m"
+_GREEN = "" if _NO_COLOR else "\033[32m"
+_YELLOW = "" if _NO_COLOR else "\033[1;33m"
+_BOLD = "" if _NO_COLOR else "\033[1m"
+_WHITE = "" if _NO_COLOR else "\033[1;37m"
+_RESET = "" if _NO_COLOR else "\033[0m"
+
+
+def _escape_control(s: str) -> str:
+    """Replace control characters with \\xNN escapes, keep Unicode as-is."""
+    return "".join(
+        f"\\x{ord(c):02x}" if ord(c) < 32 or ord(c) == 127 else c for c in s
+    )
+
+
+def _colorize_ndiff(left_lines: list[str], right_lines: list[str]) -> str:
+    """Return colorized ndiff output for two sequences of lines."""
+    colored = []
+    for line in difflib.ndiff(left_lines, right_lines):
+        stripped = line.rstrip("\n")
+        if line.startswith("- "):
+            colored.append(f"{_RED}{stripped}{_RESET}\n")
+        elif line.startswith("+ "):
+            colored.append(f"{_GREEN}{stripped}{_RESET}\n")
+        elif line.startswith("? "):
+            colored.append(f"{_YELLOW}{stripped}{_RESET}\n")
+        else:
+            colored.append(line)
+    return "".join(colored)
+
+
+def _repr_value(val: object) -> str:
+    """Return repr of a value, truncated to 200 chars."""
+    r = repr(val)
+    return r if len(r) <= 200 else r[:200] + "..."
+
+
+def _to_lines(obj: object) -> list[str]:
+    """Pretty-format *obj* into a list of lines ending with ``\\n``."""
+    fmt = pprint.PrettyPrinter(width=1, sort_dicts=False).pformat
+    lines = fmt(obj).splitlines(keepends=True)
+    if lines and not lines[-1].endswith("\n"):
+        lines[-1] += "\n"
+    return lines
+
+
+def format_sa_data(sa_data: tuple) -> str:
+    """Format captured ``_sa_data`` into a colorized error string."""
+    tag, _source, *rest = sa_data
+
+    if tag == "cmp":
+        op, left, right = rest
+        result = (
+            f"{_RED}{_repr_value(left)}{_RESET} "
+            f"{_BOLD}{op}{_RESET} "
+            f"{_GREEN}{_repr_value(right)}{_RESET}"
+        )
+        if (
+            op in {"==", "!="}
+            and isinstance(left, str)
+            and isinstance(right, str)
+        ):
+            esc = _escape_control
+            result += "\n" + _colorize_ndiff(
+                [esc(left) + "\n"],
+                [esc(right) + "\n"],
+            )
+        elif (
+            op in {"==", "!="}
+            and isinstance(left, (dict, list, tuple, set, frozenset))
+            and isinstance(right, (dict, list, tuple, set, frozenset))
+        ):
+            result += "\n" + _colorize_ndiff(
+                _to_lines(left),
+                _to_lines(right),
+            )
+        return result
+
+    if tag == "val":
+        (value,) = rest
+        return f"{_RED}{_repr_value(value)}{_RESET}"
+
+    return str(sa_data)

promium-3.9.2/promium/_soft_assert_rewrite.py

@@ -0,0 +1,249 @@
+"""AST rewriter for ``soft_assert`` calls.
+
+Transforms ``self.soft_assert(expr, ...)`` at **import time** so that
+sub-expressions are evaluated into temporary variables *before* the
+comparison.  The captured values are forwarded to ``soft_assert`` via
+the hidden ``_sa_data`` keyword argument, eliminating the need for
+runtime ``eval()`` and preventing double-evaluation of side-effecting
+expressions like ``list.pop()``.
+
+The rewriter is installed as an import hook via :func:`install` (called
+from ``promium.plugin.pytest_configure``).
+"""
+
+from __future__ import annotations
+import ast
+import contextlib
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    import types
+
+
+_COMPARE_OPS: dict[type, str] = {
+    ast.Eq: "==",
+    ast.NotEq: "!=",
+    ast.Lt: "<",
+    ast.LtE: "<=",
+    ast.Gt: ">",
+    ast.GtE: ">=",
+    ast.Is: "is",
+    ast.IsNot: "is not",
+    ast.In: "in",
+    ast.NotIn: "not in",
+}
+
+
+class SoftAssertTransformer(ast.NodeTransformer):
+    """Rewrite ``self.soft_assert(expr, ...)`` into temp-var assignments
+    followed by a call that carries ``_sa_data`` with pre-computed values.
+    """
+
+    def __init__(self, source: str) -> None:
+        self._source = source
+        self._counter = 0
+        self.changed = False
+
+    def _tmp(self) -> str:
+        name = f"@_sa_{self._counter}"
+        self._counter += 1
+        return name
+
+    def _assign(self, name: str, value: ast.expr, donor: ast.AST) -> ast.Assign:
+        stmt = ast.Assign(
+            targets=[ast.Name(id=name, ctx=ast.Store())],
+            value=value,
+        )
+        ast.copy_location(stmt, donor)
+        ast.fix_missing_locations(stmt)
+        return stmt
+
+    def _finish(
+        self,
+        stmts: list[ast.stmt],
+        call: ast.Call,
+        new_first_arg: ast.expr,
+        sa_data: ast.Tuple,
+        donor: ast.AST,
+    ) -> list[ast.stmt]:
+        new_call = ast.Call(
+            func=call.func,
+            args=[new_first_arg, *call.args[1:]],
+            keywords=[
+                *call.keywords,
+                ast.keyword(arg="_sa_data", value=sa_data),
+            ],
+        )
+        stmt = ast.Expr(value=new_call)
+        ast.copy_location(stmt, donor)
+        ast.fix_missing_locations(stmt)
+        stmts.append(stmt)
+        return stmts
+
+    def visit_Expr(self, node: ast.Expr) -> ast.AST:
+        self.generic_visit(node)
+        call = node.value
+        if not (
+            isinstance(call, ast.Call)
+            and isinstance(call.func, ast.Attribute)
+            and call.func.attr == "soft_assert"
+            and call.args
+            and not any(kw.arg == "_sa_data" for kw in call.keywords)
+        ):
+            return node
+
+        expr_arg = call.args[0]
+        source = ast.get_source_segment(self._source, expr_arg) or ""
+        n = ast.Name
+
+        self.changed = True
+
+        if isinstance(expr_arg, ast.Compare) and len(expr_arg.ops) == 1:
+            ln, rn = self._tmp(), self._tmp()
+            stmts = [
+                self._assign(ln, expr_arg.left, node),
+                self._assign(rn, expr_arg.comparators[0], node),
+            ]
+            new_expr = ast.Compare(
+                left=n(id=ln, ctx=ast.Load()),
+                ops=list(expr_arg.ops),
+                comparators=[n(id=rn, ctx=ast.Load())],
+            )
+            op_str = _COMPARE_OPS.get(type(expr_arg.ops[0]), "??")
+            sa_data = ast.Tuple(
+                elts=[
+                    ast.Constant(value="cmp"),
+                    ast.Constant(value=source),
+                    ast.Constant(value=op_str),
+                    n(id=ln, ctx=ast.Load()),
+                    n(id=rn, ctx=ast.Load()),
+                ],
+                ctx=ast.Load(),
+            )
+        else:
+            vn = self._tmp()
+            stmts = [self._assign(vn, expr_arg, node)]
+            new_expr = n(id=vn, ctx=ast.Load())
+            sa_data = ast.Tuple(
+                elts=[
+                    ast.Constant(value="val"),
+                    ast.Constant(value=source),
+                    n(id=vn, ctx=ast.Load()),
+                ],
+                ctx=ast.Load(),
+            )
+
+        return self._finish(stmts, call, new_expr, sa_data, node)
+
+
+class _SoftAssertLoader(importlib.abc.Loader):
+    """Loader that compiles a module from AST-rewritten source."""
+
+    def __init__(self, origin: str) -> None:
+        self._origin = origin
+
+    def create_module(  # noqa: PLR6301
+        self,
+        spec: importlib.machinery.ModuleSpec,
+    ) -> None:
+        return None
+
+    def exec_module(self, module: types.ModuleType) -> None:
+        module.__file__ = self._origin
+        source = Path(self._origin).read_text("utf-8")
+
+        tree = ast.parse(source, filename=self._origin)
+        transformer = SoftAssertTransformer(source)
+        tree = transformer.visit(tree)
+
+        if transformer.changed:
+            ast.fix_missing_locations(tree)
+
+        try:
+            from _pytest.assertion.rewrite import rewrite_asserts
+
+            rewrite_asserts(tree, source.encode("utf-8"))
+        except Exception:  # noqa: BLE001
+            pass
+
+        code = compile(tree, self._origin, "exec")
+        exec(code, module.__dict__)  # noqa: S102
+
+
+class SoftAssertImportHook(importlib.abc.MetaPathFinder):
+    """Import hook that rewrites ``soft_assert`` calls in test modules."""
+
+    def __init__(self) -> None:
+        self._finding: set[str] = set()
+
+    def find_spec(
+        self,
+        name: str,
+        path: object = None,
+        target: object = None,
+    ) -> importlib.machinery.ModuleSpec | None:
+        if name in self._finding:
+            return None
+
+        parts = name.split(".")
+        last = parts[-1]
+        if not (last.startswith("test_") or last == "conftest"):
+            return None
+
+        self._finding.add(name)
+        try:
+            spec = importlib.util.find_spec(name)
+            if not (
+                spec
+                and spec.origin
+                and spec.origin.endswith(".py")
+                and Path(spec.origin).exists()
+            ):
+                return None
+
+            source = Path(spec.origin).read_text("utf-8")
+            if "soft_assert" not in source:
+                return None
+
+            new_spec = importlib.machinery.ModuleSpec(
+                name,
+                _SoftAssertLoader(spec.origin),
+                origin=spec.origin,
+                is_package=spec.submodule_search_locations is not None,
+            )
+            new_spec.has_location = True
+            if spec.submodule_search_locations is not None:
+                new_spec.submodule_search_locations = list(
+                    spec.submodule_search_locations,
+                )
+            return new_spec
+        except Exception:  # noqa: BLE001
+            return None
+        finally:
+            self._finding.discard(name)
+
+
+_hook_instance: SoftAssertImportHook | None = None
+
+
+def install() -> None:
+    """Install the import hook at the front of ``sys.meta_path``."""
+    global _hook_instance  # noqa: PLW0603
+    if _hook_instance is None:
+        _hook_instance = SoftAssertImportHook()
+        sys.meta_path.insert(0, _hook_instance)
+
+
+def uninstall() -> None:
+    """Remove the import hook from ``sys.meta_path``."""
+    global _hook_instance  # noqa: PLW0603
+    if _hook_instance is not None:
+        with contextlib.suppress(ValueError):
+            sys.meta_path.remove(_hook_instance)
+        _hook_instance = None

{promium-3.9.0 → promium-3.9.2}/promium/assertions.py

@@ -11,7 +11,7 @@ import urllib3
 from json_checker import Checker, CheckerError
 from selenium.webdriver.remote.webdriver import WebDriver as SeleniumWebDriver
 
-from promium._introspect import _RESET, _WHITE, extract_call_expression
+from promium._introspect import _RESET, _WHITE, format_sa_data
 from promium.common import upload_screenshot
 
 
@@ -161,10 +161,11 @@ class BaseSoftAssertion:
         msg: str | None = None,
         with_screen: bool = False,
         hard_assert: bool | None = None,
+        _sa_data: tuple | None = None,
     ) -> None:
         """Check that the expression is true."""
         if not expr:
-            source_expr = extract_call_expression("soft_assert")
+            source_expr = format_sa_data(_sa_data) if _sa_data else None
             parts = []
             if msg:
                 parts.append(f"{_WHITE}{msg}{_RESET}")

{promium-3.9.0 → promium-3.9.2}/promium/base.py

@@ -62,7 +62,7 @@ from promium.waits import (
 log = logging.getLogger(__name__)
 
 MAX_TRIES = 20
-NORMAL_LOAD_TIME = 10
+NORMAL_LOAD_TIME = 15
 
 
 def with_retries(tries: int, second_to_wait: float) -> Any:
@@ -274,23 +274,23 @@ class Page:
         """Wait until page animations complete."""
         wait_for_animation(self.driver)
 
-    def wait_document_status(self, seconds: float = NORMAL_LOAD_TIME) -> None:
+    def wait_document_status(self, timeout: int = NORMAL_LOAD_TIME) -> None:
         """Wait until document readyState is complete."""
-        wait_document_status(self.driver, seconds=seconds)
+        wait_document_status(self.driver, timeout=timeout)
 
     def wait_websocket_connection_open(
-        self, seconds: float = NORMAL_LOAD_TIME
+        self, timeout: int = NORMAL_LOAD_TIME
     ) -> None:
         """Wait until websocket connection is established."""
-        wait_websocket_connection_open(self.driver, seconds=seconds)
+        wait_websocket_connection_open(self.driver, timeout=timeout)
 
-    def wait_for_alert(self, seconds: float = NORMAL_LOAD_TIME) -> Alert:
+    def wait_for_alert(self, timeout: int = NORMAL_LOAD_TIME) -> Alert:
         """Wait until an alert is present and return it."""
-        return wait_for_alert(self.driver, seconds=seconds)
+        return wait_for_alert(self.driver, timeout=timeout)
 
-    def is_alert_displayed(self, seconds: float = NORMAL_LOAD_TIME) -> bool:
+    def is_alert_displayed(self, timeout: int = NORMAL_LOAD_TIME) -> bool:
         """Return True if an alert is displayed within timeout."""
-        return wait_for_alert_is_displayed(self.driver, seconds=seconds)
+        return wait_for_alert_is_displayed(self.driver, timeout=timeout)
 
     def switch_to_tab(self) -> None:
         """Switch to a newly opened browser tab."""
@@ -326,7 +326,7 @@ class Page:
         scroll_into_end(self.driver)
 
     def find_network_log(
-        self, find_mask: str, find_status: int = 200, timeout: float = 5
+        self, find_mask: str, find_status: int = 200, timeout: int = 5
     ) -> list:
         """Find and return network log entries matching given mask and status."""
         return find_network_log(self.driver, find_mask, find_status, timeout)
@@ -606,7 +606,7 @@ class Collection(Base, Sequence):
         index = random.randint(0, len(elements) - 1)
         return self.get_item(index)
 
-    def wait_empty(self, timeout: float = 10) -> Self:
+    def wait_empty(self, timeout: float = NORMAL_LOAD_TIME) -> Self:
         """
         Wait until the collection becomes empty.
 
@@ -643,7 +643,7 @@ class Collection(Base, Sequence):
             )
             raise ElementLocationException(digest) from e
 
-    def wait_not_empty(self, timeout: float = 10) -> Self:
+    def wait_not_empty(self, timeout: float = NORMAL_LOAD_TIME) -> Self:
         """
         Wait until the collection becomes non-empty.
 
@@ -881,7 +881,9 @@ class ElementBase(Base):
         }
         return type(f"{cls.__name__}List", (Collection,), params)(by, locator)
 
-    def wait_to_display(self, timeout: int = 10, msg: str = "") -> Self:
+    def wait_to_display(
+            self, timeout: int = NORMAL_LOAD_TIME, msg: str = ""
+    ) -> Self:
         """
         Wait until the element is visible.
 
@@ -924,7 +926,9 @@ class ElementBase(Base):
                 digest = f"{digest}\n{msg}"
             raise ElementLocationException(digest) from None
 
-    def wait_to_present(self, timeout: int = 10, msg: str = "") -> Self:
+    def wait_to_present(
+            self, timeout: int = NORMAL_LOAD_TIME, msg: str = ""
+    ) -> Self:
         """
         Wait until the element is present in DOM.
 
@@ -954,7 +958,9 @@ class ElementBase(Base):
                 digest = f"{digest}\n{msg}"
             raise ElementLocationException(digest) from None
 
-    def wait_to_disappear(self, timeout: int = 10, msg: str = "") -> bool | None:
+    def wait_to_disappear(
+            self, timeout: int = NORMAL_LOAD_TIME, msg: str = ""
+    ) -> bool | None:
         """
         Wait until element disappears from DOM or is hidden.
 
@@ -1002,12 +1008,12 @@ class ElementBase(Base):
                 digest = f"{digest}\n{msg}"
             raise ElementLocationException(digest) from None
 
-    def wait_in_viewport(self, time: int = 5) -> Self:
+    def wait_in_viewport(self, timeout: int = NORMAL_LOAD_TIME) -> Self:
         """
         Wait until the element is in the viewport.
 
         Args:
-            time: Maximum wait time in seconds.
+            timeout: Maximum wait time in seconds.
 
         Raises:
             ElementLocationException: If element is not in viewport.
@@ -1032,7 +1038,7 @@ class ElementBase(Base):
                 expression=lambda driver: driver.execute_script(
                     jquery_script, self.lookup()
                 ),
-                seconds=time,
+                timeout=timeout,
                 msg="",
             )
             return self
@@ -1042,7 +1048,7 @@ class ElementBase(Base):
                 title="Element is not in viewport",
                 locator=css,
                 condition="inViewport == true",
-                timeout=time,
+                timeout=timeout,
                 **self._digest_ctx(),
             )
             raise ElementLocationException(digest) from e
@@ -1349,7 +1355,6 @@ class Element(ElementBase):
             return wait_until(
                 driver=self.driver,
                 expression=EC.staleness_of(self.lookup()),
-                seconds=10,
             )
         except TimeoutException as e:
             digest = build_digest(
@@ -1372,7 +1377,6 @@ class Element(ElementBase):
                 expression=EC.frame_to_be_available_and_switch_to_it(
                     self.lookup()
                 ),
-                seconds=10,
             )
         except TimeoutException as e:
             digest = build_digest(
@@ -1397,7 +1401,6 @@ class Element(ElementBase):
         try:
             return wait_until(
                 driver=self.driver,
-                seconds=10,
                 expression=text_to_be_present_in_element(self, text),
                 msg="",
             )
@@ -1476,7 +1479,6 @@ class Element(ElementBase):
             return wait_until(
                 driver=self.driver,
                 expression=lambda driver: text != self.get_attribute(name_attr),
-                seconds=10,
                 msg="",
             )
         except TimeoutException as e:
@@ -1504,7 +1506,6 @@ class Element(ElementBase):
             return wait_until(
                 driver=self.driver,
                 expression=lambda driver: element_text != self.text,
-                seconds=5,
                 msg="",
             )
         except TimeoutException as e:
@@ -1518,18 +1519,18 @@ class Element(ElementBase):
             )
             raise ElementLocationException(digest) from e
 
-    def wait_to_enabled(self, time: int = 10) -> Self:
+    def wait_to_enabled(self, timeout: int = NORMAL_LOAD_TIME) -> Self:
         """
         Wait until element is enabled (not disabled).
 
         Args:
-            time: Maximum wait time in seconds.
+            timeout: Maximum wait time in seconds.
         """
         css = self._fmt_locator()
-        push_step(f'wait_to_enabled("{css}", {time}s)')
+        push_step(f'wait_to_enabled("{css}", {timeout}s)')
         try:
             wait = WebDriverWait(
-                self.driver, time, ignored_exceptions=[WebDriverException]
+                self.driver, timeout, ignored_exceptions=[WebDriverException]
             )
             return wait.until(
                 lambda driver: self
@@ -1542,7 +1543,7 @@ class Element(ElementBase):
                 title="Element is not enabled",
                 locator=css,
                 condition='attribute "disabled" != "true"',
-                timeout=time,
+                timeout=timeout,
                 **self._digest_ctx(),
             )
             raise ElementLocationException(digest) from e

{promium-3.9.0 → promium-3.9.2}/promium/common.py

@@ -316,7 +316,7 @@ def find_network_log(
     driver: Any,
     find_mask: str,
     find_status: int = 200,
-    timeout: int = 5,
+    timeout: int = 10,
     find_type: str | None = None,
 ) -> list[dict[str, Any]]:
     """

{promium-3.9.0 → promium-3.9.2}/promium/plugin.py

@@ -473,6 +473,10 @@ def pytest_runtest_makereport(item: pytest.Item, call: CallInfo) -> None:
 
 
 def pytest_configure(config: Config) -> None:
+    from promium._soft_assert_rewrite import install as _install_sa_hook
+
+    _install_sa_hook()
+
     os.environ["PYTHONWARNINGS"] = (
         "ignore:An HTTPS request has been made, "
         "ignore:A true SSLContext object is not available, "
@@ -489,3 +493,9 @@ def pytest_configure(config: Config) -> None:
         os.environ["CHECK_CONSOLE"] = "Enabled"
     if not getattr(config, "lastfailed_file", None):
         config.lastfailed_file = "lastfailed"
+
+
+def pytest_unconfigure(config: Config) -> None:
+    from promium._soft_assert_rewrite import uninstall as _uninstall_sa_hook
+
+    _uninstall_sa_hook()