Promium 3.8.2__tar.gz → 3.9.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Promium
-Version: 3.8.2
+Version: 3.9.0
 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.8.2 → promium-3.9.0}/Promium.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Promium
-Version: 3.8.2
+Version: 3.9.0
 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.8.2 → promium-3.9.0}/Promium.egg-info/SOURCES.txt

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

promium-3.9.0/promium/_introspect.py

@@ -0,0 +1,206 @@
+"""AST-based expression introspection for soft_assert.
+
+Extracts the source expression from a ``soft_assert(...)`` call,
+substitutes runtime values, and returns a colorized string with
+a diff (for strings and containers) similar to pytest assertion output.
+"""
+
+import ast
+import difflib
+import inspect
+import os
+import pprint
+from pathlib import Path
+from typing import Any
+
+
+_SENTINEL = object()
+
+_COMPARE_OPS = {
+    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",
+}
+
+_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 extract_call_expression(method_name: str) -> str | None:
+    """Extract the first argument source from a call to *method_name*
+    and rebuild it with runtime values substituted.
+
+    Example: ``self.soft_assert(code in var)``
+    where code='23', var=[1,2,3] → ``"'23' in [1, 2, 3]"``
+    """
+    try:
+        caller = inspect.currentframe().f_back.f_back
+        source = Path(caller.f_code.co_filename).read_text(encoding="utf-8")
+
+        for node in ast.walk(ast.parse(source)):
+            if not (
+                isinstance(node, ast.Call)
+                and isinstance(node.func, ast.Attribute)
+                and node.func.attr == method_name
+                and node.args
+                and node.lineno
+                <= caller.f_lineno
+                <= (node.end_lineno or node.lineno)
+            ):
+                continue
+
+            expr_node = node.args[0]
+            expr_source = ast.get_source_segment(source, expr_node)
+            if not expr_source:
+                return None
+
+            def _may_have_side_effect(node: ast.expr) -> bool:
+                if isinstance(node, ast.Call):
+                    return True
+                if isinstance(node, ast.Attribute):
+                    if _may_have_side_effect(node.value):
+                        return True
+                    val_src = ast.get_source_segment(source, node.value)
+                    if val_src:
+                        try:
+                            obj = eval(
+                                val_src, caller.f_globals, caller.f_locals
+                            )  # noqa: S307
+                            if isinstance(
+                                getattr(type(obj), node.attr, None),
+                                property,
+                            ):
+                                return True
+                        except Exception:
+                            pass
+                    return False
+                return any(
+                    _may_have_side_effect(child)
+                    for child in ast.iter_child_nodes(node)
+                    if isinstance(child, ast.expr)
+                )
+
+            def _try_eval(operand: ast.expr) -> Any:
+                """Return the runtime value or _SENTINEL if eval fails."""
+                if _may_have_side_effect(operand):
+                    return _SENTINEL
+                src = ast.get_source_segment(source, operand)
+                if not src:
+                    return _SENTINEL
+                try:
+                    return eval(src, caller.f_globals, caller.f_locals)  # noqa: S307
+                except Exception:
+                    return _SENTINEL
+
+            def _eval_operand(operand: ast.expr) -> str:
+                """Return repr(value) if eval succeeds, otherwise source text."""
+                val = _try_eval(operand)
+                if val is _SENTINEL:
+                    return ast.get_source_segment(source, operand) or "?"
+                r = repr(val)
+                return r if len(r) <= 200 else r[:200] + "..."
+
+            if isinstance(expr_node, ast.Compare):
+                left_repr = _eval_operand(expr_node.left)
+                parts = [f"{_RED}{left_repr}{_RESET}"]
+                for cmp_op, comp in zip(expr_node.ops, expr_node.comparators):
+                    op_str = _COMPARE_OPS.get(type(cmp_op), "??")
+                    parts.append(f"{_BOLD}{op_str}{_RESET}")
+                    parts.append(f"{_GREEN}{_eval_operand(comp)}{_RESET}")
+                result = " ".join(parts)
+
+                if len(expr_node.ops) == 1 and isinstance(
+                    expr_node.ops[0], (ast.Eq, ast.NotEq)
+                ):
+                    left_val = _try_eval(expr_node.left)
+                    right_val = _try_eval(expr_node.comparators[0])
+                    if isinstance(left_val, str) and isinstance(right_val, str):
+                        esc = _escape_control
+                        result += "\n" + _colorize_ndiff(
+                            [esc(left_val) + "\n"],
+                            [esc(right_val) + "\n"],
+                        )
+                    elif (
+                        left_val is not _SENTINEL
+                        and right_val is not _SENTINEL
+                        and isinstance(
+                            left_val,
+                            (dict, list, tuple, set, frozenset),
+                        )
+                        and isinstance(
+                            right_val,
+                            (dict, list, tuple, set, frozenset),
+                        )
+                    ):
+                        fmt = pprint.PrettyPrinter(
+                            width=1, sort_dicts=False
+                        ).pformat
+                        left_lines = fmt(left_val).splitlines(keepends=True)
+                        right_lines = fmt(right_val).splitlines(keepends=True)
+                        if left_lines and not left_lines[-1].endswith("\n"):
+                            left_lines[-1] += "\n"
+                        if right_lines and not right_lines[-1].endswith("\n"):
+                            right_lines[-1] += "\n"
+                        result += "\n" + _colorize_ndiff(left_lines, right_lines)
+                return result
+
+            if isinstance(expr_node, ast.BoolOp):
+                op_str = " and " if isinstance(expr_node.op, ast.And) else " or "
+                colored_parts = []
+                for v in expr_node.values:
+                    val = _try_eval(v)
+                    operand_str = _eval_operand(v)
+                    if val is _SENTINEL:
+                        colored_parts.append(operand_str)
+                    elif val:
+                        colored_parts.append(f"{_GREEN}{operand_str}{_RESET}")
+                    else:
+                        colored_parts.append(f"{_RED}{operand_str}{_RESET}")
+                return (f"{_BOLD}{op_str}{_RESET}").join(colored_parts)
+
+            val = _try_eval(expr_node)
+            operand_str = _eval_operand(expr_node)
+            if val is not _SENTINEL and not val:
+                return f"{_RED}{operand_str}{_RESET}"
+            return operand_str
+    except Exception:
+        pass
+    return None

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

@@ -11,6 +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.common import upload_screenshot
 
 
@@ -154,6 +155,26 @@ class BaseSoftAssertion:
             return f"\nScreenshot: {upload_screenshot(self.driver)}\n"
         return ""
 
+    def soft_assert(
+        self,
+        expr: Any,
+        msg: str | None = None,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
+    ) -> None:
+        """Check that the expression is true."""
+        if not expr:
+            source_expr = extract_call_expression("soft_assert")
+            parts = []
+            if msg:
+                parts.append(f"{_WHITE}{msg}{_RESET}")
+            if source_expr:
+                parts.append(f"Assertion failed: {source_expr}")
+            error = "\n".join(parts)
+            self._emit(
+                error, with_screen=with_screen, hard_assert_override=hard_assert
+            )
+
     def soft_assert_true(
         self,
         expr: Any,

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

@@ -303,17 +303,20 @@ def _render_panel(text: str, title: str) -> str:
     border_style = "none" if mono_color else "red"
     buf = io.StringIO()
     console = Console(file=buf, force_terminal=True, width=width - 5)
-    msg = (
-        Text(text.strip(), justify="left")
-        if mono_color
-        else Syntax(
-            text.strip(),
+    stripped = text.strip()
+    has_ansi = "\033[" in stripped
+    if mono_color:
+        msg = Text(stripped, justify="left")
+    elif has_ansi:
+        msg = Text.from_ansi(stripped, no_wrap=False)
+    else:
+        msg = Syntax(
+            stripped,
             "sql",
             word_wrap=True,
             theme="ansi_light",
             background_color="default",
         )
-    )
     panel = Panel(
         renderable=msg,
         title=color_msg(title),
@@ -326,7 +329,7 @@ def _render_panel(text: str, title: str) -> str:
 
 @pytest.mark.trylast
 def pytest_runtest_call(item: pytest.Item) -> None:
-    separator = "-" * 46
+    separator = "-" * 80
     use_rich = os.getenv("PROMIUM_ASSERTION_PANEL_WIDTH") is not None
 
     if hasattr(item.config, "assertion_errors"):

{promium-3.8.2 → promium-3.9.0}/setup.py

@@ -19,7 +19,7 @@ LONG_DESCRIPTION = Path("README.rst").read_text(encoding="utf-8")
 
 setup(
     name="Promium",
-    version="3.8.2",
+    version="3.9.0",
     install_requires=REQUIREMENTS,
     author=(
         "Denis Korytkin, Nataliia Guieva, "

{promium-3.8.2 → promium-3.9.0}/tests/test_exceptions.py

@@ -158,41 +158,3 @@ def test_promium_timeout_exception_attributes():
         raise exc
     assert exc_info.value.message == exc.message
     assert str(exc_info.value) == exc.message
-
-
-@pytest.mark.unit
-def test_zzz_promium_exception_coverage_reload():
-    """Test to ensure exceptions module is loaded for coverage.
-
-    Named with "zzz_" prefix to run last and avoid breaking other tests.
-    """
-    import importlib
-    import sys
-
-    # Зберігаємо всі імпортовані exception класи
-    from promium.exceptions import (
-        BrowserConsoleException,
-        ElementLocationException,
-        LocatorException,
-        PromiumException,
-        PromiumTimeout,
-    )
-
-    saved_classes = {
-        "PromiumException": PromiumException,
-        "PromiumTimeout": PromiumTimeout,
-        "LocatorException": LocatorException,
-        "ElementLocationException": ElementLocationException,
-        "BrowserConsoleException": BrowserConsoleException,
-    }
-
-    # Перезавантажуємо для coverage
-    import promium.exceptions
-    reloaded_module = importlib.reload(promium.exceptions)
-
-    # Відновлюємо оригінальні класи в модулі
-    for class_name, original_class in saved_classes.items():
-        setattr(reloaded_module, class_name, original_class)
-
-    # Відновлюємо в sys.modules
-    sys.modules["promium.exceptions"] = reloaded_module

{promium-3.8.2 → promium-3.9.0}/tests/test_expected_conditions.py

@@ -22,13 +22,6 @@ from promium.expected_conditions import (
 )
 
 
-@pytest.mark.unit
-def test_expected_conditions_coverage():
-    import importlib
-    import promium.expected_conditions
-    importlib.reload(promium.expected_conditions)
-
-
 @pytest.fixture
 def mock_element():
     """Mock element for testing."""