Promium 3.7.4__tar.gz → 3.7.5__tar.gz

{promium-3.7.4 → promium-3.7.5}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Promium
-Version: 3.7.4
+Version: 3.7.5
 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.7.4 → promium-3.7.5}/promium/_diag.py

@@ -322,4 +322,4 @@ def build_digest(
     if origin and origin[0]:
         blocks.append(f"↳ locator at {_rel(origin[0])}:{origin[1] or '?'}")
 
-    return "\n\n".join(blocks)
+    return "\n" + "\n\n".join(blocks)

{promium-3.7.4 → promium-3.7.5}/promium/assertions.py

@@ -9,7 +9,7 @@ from typing import Any, TypeVar
 import allure
 import urllib3
 from json_checker import Checker, CheckerError
-from selenium.webdriver.chrome.webdriver import WebDriver
+from selenium.webdriver.remote.webdriver import WebDriver as SeleniumWebDriver
 
 from promium.common import upload_screenshot
 
@@ -73,11 +73,26 @@ def get_text_with_ignore_whitespace_symbols(text: str) -> str:
     return " ".join(text_list_without_space)
 
 
+class PromiumAssertionError(AssertionError):
+    """Immediate failure with Promium formatting."""
+
+
 class BaseSoftAssertion:
     """Base class for soft assertion utilities."""
 
-    # TODO is not cleaned in unit tests need use __init__
-    assertion_errors = []
+    assertion_errors: list[str] = []
+
+    def _ensure_state(self) -> None:
+        """Ensure instance fields exist when __init__ wasn't called."""
+        if (
+            not hasattr(self, "assertion_errors")
+            or self.assertion_errors is None
+        ):
+            self.assertion_errors = []
+        if not hasattr(self, "hard_assert"):
+            self.hard_assert = False
+        if not hasattr(self, "driver"):
+            self.driver = None
 
     def _relpath(self, p: str) -> str:
         """Return relative path from current working directory."""
@@ -96,9 +111,37 @@ class BaseSoftAssertion:
         f = inspect.stack()[2]
         return f"↳ at {self._relpath(f.filename)}:{f.lineno}"
 
+    def _format_error(self, error_msg: str, *, with_screen: bool) -> str:
+        """Build final error text."""
+        screen = self.add_screenshot(error_msg) if with_screen else ""
+        return f"{error_msg}{screen}\n{self._callsite_line()}\n"
+
+    def _emit(
+        self,
+        error_msg: str,
+        with_screen: bool,
+        hard_assert_override: bool | None,
+    ) -> None:
+        self._ensure_state()
+        formatted = self._format_error(error_msg, with_screen=with_screen)
+        effective_hard_assert = (
+            self.hard_assert
+            if hard_assert_override is None
+            else hard_assert_override
+        )
+
+        if effective_hard_assert:
+            __tracebackhide__ = True
+            title = "Hard Assertion Error"
+            message = f"{title}\n\n{formatted}"
+            raise AssertionError(message)
+
+        self.assertion_errors.append(formatted)
+
     def add_screenshot(self, error_msg: str = "soft_assertion") -> str:
         """Attach screenshot to allure report if driver is available."""
-        if hasattr(self, "driver"):
+        self._ensure_state()
+        if getattr(self, "driver", None):
             try:
                 allure.attach(
                     self.driver.get_screenshot_as_png(),
@@ -111,36 +154,48 @@ class BaseSoftAssertion:
         return ""
 
     def soft_assert_true(
-        self, expr: Any, msg: str = None, with_screen: bool = False
+        self,
+        expr: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that the expression is true."""
         if not expr:
             error = msg or "Is not true."
-            screen = self.add_screenshot(error) if with_screen else ""
-            self.assertion_errors.append(
-                f"{error}{screen}\n{self._callsite_line()}\n"
+            self._emit(
+                error, with_screen=with_screen, hard_assert_override=hard_assert
             )
             return error
+        return None
 
     def soft_assert_false(
-        self, expr: Any, msg: str = None, with_screen: bool = False
+        self,
+        expr: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that the expression is false."""
         if expr:
             error = msg or "Is not false."
-            screen = self.add_screenshot(error) if with_screen else ""
-            self.assertion_errors.append(
-                f"{error}{screen}\n{self._callsite_line()}\n"
+            self._emit(
+                error, with_screen=with_screen, hard_assert_override=hard_assert
             )
             return error
+        return None
 
     def soft_assert_equals(
         self,
         current: Any,
         expected: Any,
-        msg: str = None,
+        msg: str | None = None,
+        *,
         show_diff: bool = False,
         with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that current equals expected, optionally showing diff."""
         diff = None
@@ -165,15 +220,20 @@ class BaseSoftAssertion:
             f"{difference}"
         )
         return self.soft_assert_true(
-            current == expected, assert_message, with_screen
+            current == expected,
+            assert_message,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
         )
 
     def soft_assert_not_equals(
         self,
         current: Any,
         expected: Any,
-        msg: str = None,
+        msg: str | None = None,
+        *,
         with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that current does not equal expected."""
         message = (
@@ -181,118 +241,219 @@ class BaseSoftAssertion:
             f"Current - {convert_container(current)}\n"
             f"Expected - {convert_container(expected)}\n"
         )
-        self.soft_assert_false(current == expected, message, with_screen)
+        return self.soft_assert_false(
+            current == expected,
+            message,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_in(
         self,
         member: Any,
         container: Any,
-        msg: str = None,
+        msg: str | None = None,
+        *,
         with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that member is in container."""
-        msg = (
+        message = (
             f"{base_msg(msg)}\n"
             f"Member: '{member}'\n not found in\n"
             f"Container: '{convert_container(container)}'\n"
         )
-        return self.soft_assert_true(member in container, msg, with_screen)
+        return self.soft_assert_true(
+            member in container,
+            message,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_not_in(
         self,
         member: Any,
         container: Any,
-        msg: str = None,
+        msg: str | None = None,
+        *,
         with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that member is not in container."""
-        msg = (
+        message = (
             f"{base_msg(msg)}\n"
             f"Member: '{member}'\n unexpectedly found in\n"
             f"Container: '{convert_container(container)}'\n"
         )
-        return self.soft_assert_true(member not in container, msg, with_screen)
+        return self.soft_assert_true(
+            member not in container,
+            message,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_less_equal(
-        self, a: Any, b: Any, msg: str = None, with_screen: bool = False
+        self,
+        a: Any,
+        b: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that a is less than or equal to b."""
         error = f"{base_msg(msg)}{a} not less than or equal to {b}\n"
-        return self.soft_assert_true(a <= b, error, with_screen)
+        return self.soft_assert_true(
+            a <= b, error, with_screen=with_screen, hard_assert=hard_assert
+        )
 
     def soft_assert_less(
-        self, a: Any, b: Any, msg: str = None, with_screen: bool = False
+        self,
+        a: Any,
+        b: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that a is less than b."""
         error = f"{base_msg(msg)}{a} not less than {b}\n"
-        return self.soft_assert_true(a < b, error, with_screen)
+        return self.soft_assert_true(
+            a < b, error, with_screen=with_screen, hard_assert=hard_assert
+        )
 
     def soft_assert_greater_equal(
-        self, a: Any, b: Any, msg: str = None, with_screen: bool = False
+        self,
+        a: Any,
+        b: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that a is greater than or equal to b."""
         error = f"{base_msg(msg)}{a} not greater than or equal to {b}\n"
-        return self.soft_assert_true(a >= b, error, with_screen)
+        return self.soft_assert_true(
+            a >= b, error, with_screen=with_screen, hard_assert=hard_assert
+        )
 
     def soft_assert_greater(
-        self, a: Any, b: Any, msg: str = None, with_screen: bool = False
+        self,
+        a: Any,
+        b: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that a is greater than b."""
         error = f"{base_msg(msg)}{a} not greater than {b}\n"
-        return self.soft_assert_true(a > b, error, with_screen)
+        return self.soft_assert_true(
+            a > b, error, with_screen=with_screen, hard_assert=hard_assert
+        )
 
     def soft_assert_regexp_matches(
-        self, text: str, expected_regexp: str, msg: str = None
+        self,
+        text: str,
+        expected_regexp: str,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Fail the test unless the text matches the regular expression."""
         pattern = re.compile(expected_regexp)
         result = pattern.search(text)
-
         if not result:
             error = (
                 f"{base_msg(msg)}"
                 f"Regexp didn't match."
                 f"Pattern {str(pattern.pattern)} not found in {str(text)}\n"
             )
-            self.assertion_errors.append(f"{error}\n{self._callsite_line()}\n")
+            self._emit(
+                error, with_screen=with_screen, hard_assert_override=hard_assert
+            )
             return error
+        return None
 
     def soft_assert_disable(
-        self, element: Any, msg: str = None, with_screen: bool = False
-    ) -> str:
+        self,
+        element: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
+    ) -> str | None:
         """Check that element has 'disabled' attribute."""
         default_msg = "" if msg else f"Not disabled {element}\n"
         error = f"{base_msg(msg)}{default_msg}"
         return self.soft_assert_true(
-            element.get_attribute("disabled"), error, with_screen
+            element.get_attribute("disabled"),
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
         )
 
-    def soft_assert_is_none(self, obj: Any, msg: str = None) -> str:
+    def soft_assert_is_none(
+        self,
+        obj: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
+    ) -> str | None:
         """Check that object is None."""
         default_msg = "" if msg else f"{obj} is not None.\n"
         error = f"{base_msg(msg)}{default_msg}"
-        return self.soft_assert_true(obj is None, error)
+        return self.soft_assert_true(
+            obj is None, error, with_screen=with_screen, hard_assert=hard_assert
+        )
 
-    def soft_assert_is_not_none(self, obj: Any, msg: str = None) -> str:
+    def soft_assert_is_not_none(
+        self,
+        obj: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
+    ) -> str | None:
         """Check that object is not None."""
         default_msg = "" if msg else "Unexpectedly None.\n"
         error = f"{base_msg(msg)}{default_msg}"
-        return self.soft_assert_true(obj is not None, error)
+        return self.soft_assert_true(
+            obj is not None,
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_is_instance(
-        self, obj: Any, cls: Any, msg: str = None
-    ) -> str:
+        self,
+        obj: Any,
+        cls: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
+    ) -> str | None:
         """Check that object is instance of given class."""
         default_msg = "" if msg else f"{obj} is not an instance of {cls}.\n"
         error = f"{base_msg(msg)}{default_msg}"
-        return self.soft_assert_true(isinstance(obj, cls), error)
+        return self.soft_assert_true(
+            isinstance(obj, cls),
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_equals_text_with_ignore_spaces_and_register(
         self,
         current_text: str,
         expected_text: str,
         msg: str = "Invalid checked text.",
+        *,
         with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> None:
         """Compare texts ignoring spaces and case."""
         current = get_text_with_ignore_whitespace_symbols(current_text)
@@ -304,26 +465,40 @@ class BaseSoftAssertion:
             expected.lower(),
             f"{msg}\nCurrent text without formatting: {current_text}"
             f"\nExpected text without formatting: {expected_text}",
+            show_diff=False,
             with_screen=with_screen,
+            hard_assert=hard_assert,
         )
 
     def soft_assert_schemas(
-        self, current: dict, expected: dict, msg: str = ""
+        self,
+        current: dict,
+        expected: dict,
+        msg: str = "",
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Validate dictionary schema using json_checker."""
         try:
             Checker(expected, soft=True).validate(current)
         except CheckerError as e:
             error = f"{msg}\n{e}\n"
-            self.assertion_errors.append(f"{error}\n{self._callsite_line()}\n")
+            self._emit(
+                error, with_screen=with_screen, hard_assert_override=hard_assert
+            )
             return error
+        return None
 
     def assert_keys_and_instances(
         self,
         actual_dict: dict,
         expected_dict: dict,
-        can_be_null: list = None,
-        msg: str = None,
+        can_be_null: list | None = None,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> None:
         """Check that dict keys and value types match expected."""
         assert actual_dict, "Actual dict is empty, check your data"
@@ -332,12 +507,16 @@ class BaseSoftAssertion:
             sorted(iter(actual_dict.keys())),
             sorted(iter(expected_dict.keys())),
             "Wrong keys list.",
+            with_screen=with_screen,
+            hard_assert=hard_assert,
         )
         for actual_key, actual_value in actual_dict.items():
             self.soft_assert_in(
                 member=actual_key,
                 container=expected_dict,
                 msg=f'Not expected key "{actual_key}".',
+                with_screen=with_screen,
+                hard_assert=hard_assert,
             )
             if actual_key in expected_dict:
                 expected_value = (
@@ -353,10 +532,18 @@ class BaseSoftAssertion:
                         f'Key "{actual_key}" value is "{type(actual_value)}", '
                         f'expected "{expected_value}". {message}'
                     ),
+                    with_screen=with_screen,
+                    hard_assert=hard_assert,
                 )
 
     def soft_assert_dicts_with_ignore_types(
-        self, current: Any, expected: Any, msg: str = ""
+        self,
+        current: Any,
+        expected: Any,
+        msg: str = "",
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> None:
         """Compare two dicts ignoring value types."""
         expected_dict = _check_namedtuple(expected)
@@ -371,19 +558,24 @@ class BaseSoftAssertion:
                         f"Expected: {expected_dict[actual_key]} \n"
                     )
         if errors:
-            self.assertion_errors.append(
+            error = (
                 f"{msg}{errors}"
                 f"\nExpected dict: {convert_container(expected_dict)}"
                 f"\nCurrent dict: {convert_container(current_dict)}"
-                f"\n{self._callsite_line()}\n"
+            )
+            self._emit(
+                error, with_screen=with_screen, hard_assert_override=hard_assert
             )
 
     def soft_assert_equal_dict_from_clerk_magic(
         self,
         current_dict: dict,
         expected_dict: dict,
-        msg: str = None,
+        msg: str | None = None,
         coerce: CoerceDict = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> None:
         """Compare dicts by type, coercing values if needed."""
 
@@ -418,6 +610,8 @@ class BaseSoftAssertion:
                 f"Unequal_keys:\n\t{unequal_check}\n"
                 f"\nMissed_keys:\n\t[{missing_check}]"
             ),
+            with_screen=with_screen,
+            hard_assert=hard_assert,
         )
 
 
@@ -426,9 +620,10 @@ class RequestSoftAssertion(BaseSoftAssertion):
 
     @property
     def url(self) -> str:
+        """Return current URL from session."""
         return self.session.url
 
-    def base_msg(self, msg: str = None) -> str:
+    def base_msg(self, msg: str | None = None) -> str:
         """Return formatted message including URL and optional extra message."""
         url = f"\n{self.url}" if self.url else ""
         exception = f"\n{msg}" if msg else ""
@@ -438,54 +633,112 @@ class RequestSoftAssertion(BaseSoftAssertion):
 class WebDriverSoftAssertion(BaseSoftAssertion):
     """Soft assertions for WebDriver-based checks."""
 
+    _driver: SeleniumWebDriver | None = None
+
     @property
-    def driver(self) -> WebDriver:
-        return self.driver
+    def driver(self) -> SeleniumWebDriver | None:
+        return self._driver
+
+    @driver.setter
+    def driver(self, value: SeleniumWebDriver | None) -> None:
+        self._driver = value
 
     @property
     def url(self) -> str:
-        return self.driver.current_url
+        """Return current browser URL."""
+        return self.driver.current_url if self.driver else ""
 
-    def base_msg(self, default_msg: str = None, extend_msg: str = None) -> str:
+    def base_msg(
+        self, default_msg: str | None = None, extend_msg: str | None = None
+    ) -> str:
         """Return formatted message including default, extended, and URL."""
         default = f"Default message: {default_msg}\n" if default_msg else ""
         extend = f"Extend message: {extend_msg}\n" if extend_msg else ""
         return f"{default}{extend}\nURL: {self.url}"
 
     def soft_assert_page_title(
-        self, expected_title: str, msg: str = None
+        self,
+        expected_title: str,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> None:
         """Check that page title matches expected."""
         default_msg = "Wrong page title."
         error = f"{self.base_msg(default_msg=default_msg, extend_msg=msg)}"
-        self.soft_assert_equals(self.driver.title, expected_title, error)
+        self.soft_assert_equals(
+            self.driver.title if self.driver else None,
+            expected_title,
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_current_url(
-        self, expected_url: str, msg: str = None
+        self,
+        expected_url: str,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> None:
         """Check that current URL matches expected."""
         default_msg = "Wrong current url."
         error = f"{self.base_msg(default_msg=default_msg, extend_msg=msg)}"
-        self.soft_assert_equals(self.url, expected_url, error)
+        self.soft_assert_equals(
+            self.url,
+            expected_url,
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_current_url_contains(
-        self, url_mask: str, msg: str = None
+        self,
+        url_mask: str,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> None:
         """Check that current URL contains mask."""
         default_msg = f"URL {str(self.url)} doesn't contain {str(url_mask)}."
         error = f"{self.base_msg(default_msg=default_msg, extend_msg=msg)}"
-        self.soft_assert_in(url_mask, self.url, error)
+        self.soft_assert_in(
+            url_mask,
+            self.url,
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_current_url_not_contains(
-        self, url_mask: str, msg: str = None
+        self,
+        url_mask: str,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> None:
         """Check that current URL does not contain mask."""
         default_msg = f"URL {str(self.url)} contains {str(url_mask)}."
         error = f"{self.base_msg(default_msg=default_msg, extend_msg=msg)}"
-        self.soft_assert_not_in(url_mask, self.url, error)
+        self.soft_assert_not_in(
+            url_mask,
+            self.url,
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_element_is_present(
-        self, element: Any, msg: str = None
+        self,
+        element: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = True,
+        hard_assert: bool | None = None,
     ) -> None:
         """Check that element is present in DOM."""
         default_msg = (
@@ -493,38 +746,78 @@ class WebDriverSoftAssertion(BaseSoftAssertion):
             f" on page at current time."
         )
         error = f"{self.base_msg(default_msg=default_msg, extend_msg=msg)}"
-        self.soft_assert_true(element.is_present(), error, with_screen=True)
+        self.soft_assert_true(
+            element.is_present(),
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_element_is_not_present(
-        self, element: Any, msg: str = None
+        self,
+        element: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = True,
+        hard_assert: bool | None = None,
     ) -> None:
         """Check that element is not present in DOM."""
         default_msg = f"Element {element.by}={element.locator} is found on page."
         error = f"{self.base_msg(default_msg=default_msg, extend_msg=msg)}"
-        self.soft_assert_false(element.is_present(), error, with_screen=True)
+        self.soft_assert_false(
+            element.is_present(),
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_element_is_displayed(
-        self, element: Any, msg: str = None
+        self,
+        element: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = True,
+        hard_assert: bool | None = None,
     ) -> None:
         """Check that element is visible to user."""
         default_msg = (
             f"Element {element.by}={element.locator} is not visible to a user."
         )
         error = f"{self.base_msg(default_msg=default_msg, extend_msg=msg)}"
-        self.soft_assert_true(element.is_displayed(), error, with_screen=True)
+        self.soft_assert_true(
+            element.is_displayed(),
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_element_is_not_displayed(
-        self, element: Any, msg: str = None
+        self,
+        element: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = True,
+        hard_assert: bool | None = None,
     ) -> None:
         """Check that element is not visible to user."""
         default_msg = (
             f"Element {element.by}={element.locator} is visible to a user."
         )
         error = f"{self.base_msg(default_msg=default_msg, extend_msg=msg)}"
-        self.soft_assert_false(element.is_displayed(), error, with_screen=True)
+        self.soft_assert_false(
+            element.is_displayed(),
+            error,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
+        )
 
     def soft_assert_element_displayed_in_viewport(
-        self, element: Any, msg: str = None
+        self,
+        element: Any,
+        msg: str | None = None,
+        *,
+        with_screen: bool = True,
+        hard_assert: bool | None = None,
     ) -> None:
         """Check that element is inside viewport."""
         element_in_viewport = self.driver.execute_script(
@@ -565,25 +858,34 @@ class WebDriverSoftAssertion(BaseSoftAssertion):
             error = (
                 f"{self.base_msg(default_msg=default_msg, extend_msg=msg)}\n\n"
             )
-            self.assertion_errors.append(f"{error}\n{self._callsite_line()}\n")
+            self._emit(
+                error, with_screen=with_screen, hard_assert_override=hard_assert
+            )
 
     def soft_assert_image_status_code(
-        self, image: Any, status_code: int = 200, msg: str = None
+        self,
+        image: Any,
+        status_code: int = 200,
+        msg: str | None = None,
+        *,
+        with_screen: bool = False,
+        hard_assert: bool | None = None,
     ) -> str | None:
         """Check that image URL returns expected status code."""
         if not image.get_attribute("src"):
-            return self.assertion_errors.append(
-                f"{base_msg(msg)}"
-                "Image does not have attribute"
-                f" 'src'\n\n{self._callsite_line()}\n"
+            error = f"{base_msg(msg)}Image does not have attribute 'src'\n"
+            self._emit(
+                error, with_screen=with_screen, hard_assert_override=hard_assert
             )
+            return error
 
         img_url = image.get_attribute("src")
         response = http.request(url=img_url, method="GET")
-
         assert_msg = msg if msg else "img status code != 200"
-        self.soft_assert_equals(
+        return self.soft_assert_equals(
             response.status,
             status_code,
             msg=assert_msg,
+            with_screen=with_screen,
+            hard_assert=hard_assert,
         )

{promium-3.7.4 → promium-3.7.5}/promium/plugin.py

@@ -4,6 +4,10 @@ import logging
 import os
 from _pytest.config import Config
 from _pytest.runner import CallInfo
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
 from typing import NamedTuple
 
 import allure
@@ -277,94 +281,79 @@ def color_msg(msg: str, color: str = "bold red") -> str:
     return f"[{color}]{msg}[/{color}]"
 
 
+def _panel_width() -> int:
+    env_w = os.getenv("PROMIUM_ASSERTION_PANEL_WIDTH")
+    try:
+        term_w = os.get_terminal_size().columns
+    except Exception:
+        term_w = 120
+    if env_w is None:
+        return term_w
+    try:
+        w = int(env_w)
+        if w < 0 or w > term_w:
+            return term_w
+        return w
+    except Exception:
+        return term_w
+
+
+def _render_panel(text: str, title: str) -> str:
+    width = _panel_width()
+    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(), "sql", word_wrap=True)
+    )
+    panel = Panel(
+        renderable=msg,
+        title=color_msg(title),
+        border_style=border_style,
+        padding=(1, 1),
+    )
+    console.print(panel)
+    return buf.getvalue()
+
+
 @pytest.mark.trylast
 def pytest_runtest_call(item: pytest.Item) -> None:
     separator = "-" * 46
-    if PANEL_WIDTH := os.getenv("PROMIUM_ASSERTION_PANEL_WIDTH"):
-        from rich.console import Console  # noqa: PLC0415
-        from rich.panel import Panel  # noqa: PLC0415
-        from rich.syntax import Syntax  # noqa: PLC0415
-        from rich.text import Text  # noqa: PLC0415
-
-        try:
-            terminal_width = os.get_terminal_size().columns
-        except Exception:
-            terminal_width = 120
-
-        try:
-            PANEL_WIDTH = int(PANEL_WIDTH)
-            if PANEL_WIDTH < 0 or terminal_width < PANEL_WIDTH:
-                PANEL_WIDTH = terminal_width
-        except Exception:
-            PANEL_WIDTH = terminal_width
-    if mono_color:
-        border_style = "none"
-    else:
-        border_style = "red"
+    use_rich = os.getenv("PROMIUM_ASSERTION_PANEL_WIDTH") is not None
 
     if hasattr(item.config, "assertion_errors"):
         if item.config.assertion_errors:
-            if PANEL_WIDTH:
-                string_io = io.StringIO()
-                console = Console(
-                    file=string_io,
-                    force_terminal=True,
-                    width=PANEL_WIDTH - 5,
+            if use_rich:
+                rich_output = "".join(
+                    _render_panel(err.strip(), "Soft Assertion Error")
+                    for err in item.config.assertion_errors
                 )
-                for error_text in item.config.assertion_errors:
-                    text = error_text.strip()
-                    if mono_color:
-                        msg = Text(text, justify="left")
-                    else:
-                        msg = Syntax(text, "sql", word_wrap=True)
-                    rich_panel = Panel(
-                        renderable=msg,
-                        title=color_msg("Soft Assertion Error"),
-                        border_style=border_style,
-                        padding=(1, 1),
-                    )
-                    console.print(rich_panel)
-                rich_output = string_io.getvalue()
                 raise AssertionError(f"\n{rich_output}")
-            else:  # noqa: RET506
-                assertion_errors_list = f"{separator}\n".join(
-                    item.config.assertion_errors
-                )
-                msg = f"\n{separator}\n{assertion_errors_list}{separator}\n"
-                raise AssertionError(msg)
+            assertion_errors_list = f"{separator}\n".join(
+                item.config.assertion_errors
+            )
+            msg = f"\n{separator}\n{assertion_errors_list}{separator}\n"
+            raise AssertionError(msg)
 
     if item.config.getoption("--check-console"):
         if hasattr(item.config, "check_console_errors"):
             if console_errors := item.config.check_console_errors(item):
-                if PANEL_WIDTH:
-                    string_io = io.StringIO()
-                    console = Console(
-                        file=string_io,
-                        force_terminal=True,
-                        width=PANEL_WIDTH - 5,
-                    )
-                    for error_text in console_errors:
-                        text = error_text.strip()
-                        if mono_color:
-                            msg = Text(text, justify="left")
-                        else:
-                            msg = Syntax(text, "sql", word_wrap=True)
-                        rich_panel = Panel(
-                            renderable=msg,
-                            title=color_msg("Browser console js errors found"),
-                            border_style=border_style,
-                            padding=(1, 1),
+                if use_rich:
+                    rich_output = "".join(
+                        _render_panel(
+                            err.strip(), "Browser console js errors found"
                         )
-                        console.print(rich_panel)
-                    rich_output = string_io.getvalue()
-                    raise BrowserConsoleException(f"\n{rich_output}")
-                else:  # noqa: RET506
-                    console_errors_list = f"{separator}\n".join(console_errors)
-                    msg = (
-                        f"Browser console js errors found:"
-                        f"\n{separator}\n{console_errors_list}{separator}\n"
+                        for err in console_errors
                     )
-                    raise BrowserConsoleException(msg)
+                    raise BrowserConsoleException(f"\n{rich_output}")
+                console_errors_list = f"{separator}\n".join(console_errors)
+                msg = (
+                    f"Browser console js errors found:"
+                    f"\n{separator}\n{console_errors_list}{separator}\n"
+                )
+                raise BrowserConsoleException(msg)
 
 
 @pytest.mark.tryfirst
@@ -396,7 +385,6 @@ def pytest_runtest_makereport(item: pytest.Item, call: CallInfo) -> None:
                                 name="SCREENSHOT",
                                 attachment_type=allure.attachment_type.PNG,
                             )
-
                     elif fail_debug.test_type == "request":
                         fail_info = (
                             f"\nURL: {fail_debug.url}"
@@ -423,30 +411,56 @@ def pytest_runtest_makereport(item: pytest.Item, call: CallInfo) -> None:
                             name="RUN COMMAND",
                             attachment_type=allure.attachment_type.HTML,
                         )
-
             except WebDriverException as e:
                 fail_info = f"\nWebdriver instance must have crushed: {e.msg}"
             finally:
                 longrepr = getattr(report, "longrepr", None)
                 if hasattr(longrepr, "addsection"):
-                    longrepr.sections.insert(
-                        0, (f"Captured stdout {when}", fail_info, "-")
-                    )
+                    longrepr.sections.append((
+                        f"Captured stdout {when}",
+                        fail_info,
+                        "-",
+                    ))
+                else:
+                    report.sections.append((
+                        f"Captured stdout {when}",
+                        fail_info,
+                    ))
+
+        if call.excinfo is not None:
+            exc = call.excinfo.value
+            panel_text = getattr(exc, "_promium_panel_text", None)
+            if (
+                panel_text
+                and os.getenv("PROMIUM_ASSERTION_PANEL_WIDTH") is not None
+            ):
+                title = getattr(
+                    exc, "_promium_panel_title", "Soft Assertion Error"
+                )
+                rich_output = _render_panel(panel_text, title)
+                report.sections.append((title, "\n" + rich_output))
 
-        if item.config.getoption("--duration-time"):
-            duration = call.stop - call.start
-            if duration > 120:
-                report.sections.append((
-                    f"Captured stdout {when}",
-                    (
-                        "\n\n!!!!! The very slow test. "
-                        "Duration time is {} !!!!!\n\n"
-                    ).format(
-                        datetime.datetime.fromtimestamp(duration).strftime(
-                            "%M min %S sec"
-                        )
-                    ),
-                ))
+    if call.when == "teardown" and hasattr(item, "capturelog_handler"):
+        root_logger = logging.getLogger()
+        try:
+            root_logger.removeHandler(item.capturelog_handler)
+        finally:
+            item.capturelog_handler.close()
+            del item.capturelog_handler
+
+    if item.config.getoption("--duration-time"):
+        duration = call.stop - call.start
+        if duration > 120:
+            report.sections.append((
+                f"Captured stdout {when}",
+                (
+                    "\n\n!!!!! The very slow test. Duration time is {} !!!!!\n\n"
+                ).format(
+                    datetime.datetime.fromtimestamp(duration).strftime(
+                        "%M min %S sec"
+                    )
+                ),
+            ))
 
 
 def pytest_configure(config: Config) -> None:

{promium-3.7.4 → promium-3.7.5}/setup.py

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