Promium 3.7.6__tar.gz → 3.7.7__tar.gz

{promium-3.7.6 → promium-3.7.7}/PKG-INFO

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

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

@@ -42,8 +42,12 @@ tests/conftest.py
 tests/test_catalog_404.py
 tests/test_catalog_gallery.py
 tests/test_enviroment.py
+tests/test_exceptions.py
+tests/test_expected_conditions.py
+tests/test_helpers.py
 tests/test_requests.py
 tests/test_soft_asserts.py
+tests/test_test_cases.py
 tests/test_waits.py
 tests/urls.py
 tests/pages/__init__.py

promium-3.7.7/doc/conf.py

@@ -0,0 +1,44 @@
+project = "Promium"
+copyright = "2020, evo.company"  # noqa: A001
+author = (
+    "Denis Korytkin, Nataliia Guieva, Roman Zaporozhets, "
+    "Vladimir Kritov, Oleh Dykusha"
+)
+
+extensions = [
+    "sphinx.ext.intersphinx",
+    "sphinxemoji.sphinxemoji",
+    "sphinx_autobuild",
+    # 'myst_parser',
+]
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3.7", None),
+}
+templates_path = ["_templates"]
+source_suffix = [".rst", ".md"]
+master_doc = "index"
+source_parsers = {
+   ".md": "recommonmark.parser.CommonMarkParser",
+}
+
+# html_theme = 'sphinx_rtd_theme'
+html_theme_options = {
+    "display_version": False,
+}
+html_context = {
+    "display_gitlab": True,
+    "gitlab_host": "gitlab.evo.dev",
+    "gitlab_user": "qa-automation",
+    "gitlab_repo": "qa-automation.git-doc.evo.dev/promium",
+    "gitlab_version": "master",
+    "conf_py_path": "/source/",
+}
+
+
+html_static_path = ["_static"]
+
+html_css_files = [
+        "custom.css",
+]
+
+html_favicon = "favicon.ico"

{promium-3.7.6 → promium-3.7.7}/promium/__init__.py

@@ -1,26 +1,26 @@
-from promium.base import Page, Block, Element
+from promium.base import Block, Element, Page
 from promium.elements.checkbox import Checkbox
-from promium.elements.radio_button import RadioButton
-from promium.elements.upload_button import UploadButton
+from promium.elements.drop_downs import DropDown
+from promium.elements.frame import Frame
 from promium.elements.input_field import InputField
 from promium.elements.link import Link
-from promium.elements.drop_downs import DropDown
-from promium.elements.textarea_field import TextareaField
 from promium.elements.multiselect_listbox import MultiSelectListBox
-from promium.elements.frame import Frame
+from promium.elements.radio_button import RadioButton
+from promium.elements.textarea_field import TextareaField
+from promium.elements.upload_button import UploadButton
 
 
 __all__ = (
-    'Page',
-    'Block',
-    'Element',
-    'Checkbox',
-    'RadioButton',
-    'UploadButton',
-    'InputField',
-    'TextareaField',
-    'Link',
-    'DropDown',
-    'MultiSelectListBox',
-    'Frame',
+    "Page",
+    "Block",
+    "Element",
+    "Checkbox",
+    "RadioButton",
+    "UploadButton",
+    "InputField",
+    "TextareaField",
+    "Link",
+    "DropDown",
+    "MultiSelectListBox",
+    "Frame",
 )

{promium-3.7.6 → promium-3.7.7}/promium/base.py

@@ -300,6 +300,16 @@ class Page:
         """Switch back to the previously active tab."""
         switch_to_window(self.driver, self.previous_window_handle)
 
+    def open_tab(self) -> None:
+        """Open new tab and switch to it."""
+        self.driver.execute_script("window.open();")
+        switch_to_window(self.driver, self.previous_window_handle)
+
+    def close_tab(self) -> None:
+        """Close current tab and switch to the previously tab."""
+        self.driver.close()
+        switch_to_window(self.driver, self.previous_window_handle)
+
     def scroll_to_bottom(self) -> None:
         """Scroll to the bottom of the page."""
         scroll_to_bottom(self.driver)

{promium-3.7.6 → promium-3.7.7}/promium/device_config.py

@@ -24,7 +24,7 @@ DEFAULT_USER_AGENT_HUAWEI = (
 class DesktopDevice(NamedTuple):
     width: int
     height: int
-    user_agent: str = ''
+    user_agent: str = ""
 
 
 class CustomDevice(NamedTuple):
@@ -35,6 +35,7 @@ class CustomDevice(NamedTuple):
     Usage:
         XIAOMI_REDMI_7 = CustomDevice(393, 851)
     """
+
     width: int
     height: int
     pixel_ratio: float = 1.0

{promium-3.7.6 → promium-3.7.7}/promium/elements/drop_downs.py

@@ -1,32 +1,31 @@
-
 import random
 
+from selenium.webdriver.remote.webelement import WebElement
 from selenium.webdriver.support.select import Select
 
 from promium.base import Element
 
 
 class DropDown(Element):
-
     @property
-    def drop_down(self):
+    def drop_down(self) -> Select:
         return Select(self.lookup())
 
     @property
-    def options(self):
+    def options(self) -> list[WebElement]:
         """Gets drop down options list"""
         return self.drop_down.options
 
-    def select_by_visible_text(self, text):
+    def select_by_visible_text(self, text: str) -> None:
         """Selects the option by the visible_text"""
         return self.drop_down.select_by_visible_text(text)
 
-    def select_by_value(self, value):
+    def select_by_value(self, value: str) -> None:
         """Selects the option by the given value"""
         return self.drop_down.select_by_value(value)
 
-    def select_random_option(self, without_first=False):
+    def select_random_option(self, without_first: bool = False) -> None:
         """Selects random option with or without default empty one"""
         options = self.options[1:] if without_first else self.options
-        selectable_option = random.choice(options).get_attribute('value')
+        selectable_option = random.choice(options).get_attribute("value")
         return self.select_by_value(selectable_option)

{promium-3.7.6 → promium-3.7.7}/promium/elements/frame.py

@@ -1,13 +1,11 @@
-
 from promium.base import Element
 
 
 class Frame(Element):
-
-    def switch_to_frame(self):
+    def switch_to_frame(self) -> None:
         """Switch the focus from the main page content to the specific iframe"""
         self.driver.switch_to.frame(self.lookup())
 
-    def exit_from_frame(self):
+    def exit_from_frame(self) -> None:
         """Switch the focus from the specific iframe to the main page content"""
         self.driver.switch_to.window(self.driver.current_window_handle)

{promium-3.7.6 → promium-3.7.7}/promium/elements/link.py

@@ -1,6 +1,6 @@
+import logging
 
 import urllib3
-import logging
 
 from promium.base import Element
 from promium.helpers import ParseUrl
@@ -10,13 +10,12 @@ log = logging.getLogger(__name__)
 
 
 class Link(Element):
-
     @property
-    def href(self):
+    def href(self) -> str:
         return self.get_attribute("href")
 
     @property
-    def parse_url(self):
+    def parse_url(self) -> ParseUrl:
         """
         Using parse_url to parse href. Can get attributes:
         - scheme
@@ -32,35 +31,35 @@ class Link(Element):
         return ParseUrl(self.href)
 
     @property
-    def response(self):
+    def response(self) -> urllib3.BaseHTTPResponse:
         """Get url response"""
         http = urllib3.PoolManager(
             cert_reqs=False,
             timeout=5,
         )
-        cookies_str = '; '.join([
-            f'{cookie["name"]}={cookie["value"]}'
+        cookies_str = "; ".join([
+            f"{cookie['name']}={cookie['value']}"
             for cookie in self.driver.get_cookies()
         ])
         for i in range(1, 3):
             r = http.request(
                 url=self.href,
-                method='GET',
+                method="GET",
                 headers={
-                    "Accept-Encoding": 'gzip, deflate',
+                    "Accept-Encoding": "gzip, deflate",
                     "Accept": "*/*",
                     "Connection": "keep-alive",
                     "Cookie": cookies_str,
                 },
             )
-            if r.status in [502, 503, 504]:
-                log.warning(f'[Request Retry]: attempt:{i}, status: {r.status}')
+            if r.status in {502, 503, 504}:
+                log.warning(f"[Request Retry]: attempt:{i}, status: {r.status}")
             else:
                 break
 
         return r
 
     @property
-    def get_status_code(self):
+    def get_status_code(self) -> int:
         """Gets status response code from link"""
         return self.response.status

{promium-3.7.6 → promium-3.7.7}/promium/elements/multiselect_listbox.py

@@ -1,26 +1,25 @@
-
+from selenium.webdriver.remote.webelement import WebElement
 from selenium.webdriver.support.select import Select
 
 from promium.base import Element
 
 
 class MultiSelectListBox(Element):
-
     @property
-    def listbox(self):
+    def listbox(self) -> Select:
         return Select(self.lookup())
 
     @property
-    def options(self):
+    def options(self) -> list[WebElement]:
         """Gets drop down options list"""
         return self.listbox.options
 
-    def deselect_all(self):
+    def deselect_all(self) -> None:
         """Deselects all options"""
         for opt in self.options:
             if opt.is_selected():
                 opt.click()
 
-    def select_by_visible_text(self, text):
+    def select_by_visible_text(self, text: str) -> None:
         """Selects the option by the visible_text"""
         return self.listbox.select_by_visible_text(text)

{promium-3.7.6 → promium-3.7.7}/promium/elements/radio_button.py

@@ -1,41 +1,35 @@
-
 import random
 
-from promium.base import Element
-from promium.base import Sequence
+from promium.base import Element, Sequence
 from promium.exceptions import PromiumException
 
 
 class RadioButton(Element):
-
-    def select(self):
+    def select(self) -> None:
         """Selects radio button"""
         if not self.is_selected():
             self.click()
 
-    def select_random_button(self):
+    def select_random_button(self) -> None:
         """Selects random radio button from list"""
         if isinstance(self, Sequence):
             random.random(self).select()
         else:
             raise PromiumException("Element is not a list.")
 
-    def is_one_button_already_selected(self):
+    def is_one_button_already_selected(self) -> bool:
         """Checks is one button from list already selected"""
         if isinstance(self, Sequence):
-            return len(
-                [button for button in self if button.is_selected()]
-            ) == 1
-        else:
-            raise PromiumException("Element is not a list.")
+            return len([button for button in self if button.is_selected()]) == 1
+        raise PromiumException("Element is not a list.")
 
     @property
-    def label(self):
+    def label(self) -> str:
         """Gets label"""
         return self.driver.execute_script(
             """
             element = arguments[0];
             return element.parentElement.innerText;
             """,
-            self.lookup()
+            self.lookup(),
         )

{promium-3.7.6 → promium-3.7.7}/promium/elements/textarea_field.py

@@ -1,7 +1,5 @@
-
 from promium.elements.input_field import InputField
 
 
 class TextareaField(InputField):
-
     pass

{promium-3.7.6 → promium-3.7.7}/promium/elements/upload_button.py

@@ -1,9 +1,7 @@
-
 from promium.elements.input_field import InputField
 
 
 class UploadButton(InputField):
-
-    def upload_file(self, file_path):
+    def upload_file(self, file_path: str) -> None:
         """Uploads file by file path"""
         self.send_keys(file_path)

{promium-3.7.6 → promium-3.7.7}/promium/exceptions.py

@@ -1,15 +1,18 @@
-
-
 class PromiumException(Exception):
     pass
 
 
 class PromiumTimeout(PromiumException):
-    def __init__(self, message="no error message", seconds=10, screen=None):
+    def __init__(
+        self,
+        message: str = "no error message",
+        seconds: int = 10,
+        screen: str | None = None,
+    ) -> None:
         self.message = f"{message} (waited {seconds} seconds)"
         if screen:
             self.message += "Screenshot: available via screen\n"
-        super(PromiumTimeout, self).__init__(self.message)
+        super().__init__(self.message)
 
 
 class ElementLocationException(PromiumException):

{promium-3.7.6 → promium-3.7.7}/promium/expected_conditions.py

@@ -1,25 +1,24 @@
+from typing import Any, NoReturn
 
 from promium.exceptions import PromiumException
 
 
-class BaseElementConditionWithRefresh(object):
-
-    def __init__(self, element, with_refresh=False):
+class BaseElementConditionWithRefresh:
+    def __init__(self, element: Any, with_refresh: bool = False) -> None:
         self.element = element
         self.with_refresh = with_refresh
 
-    def call_method(self):
-        raise PromiumException('Not implemented')
+    def call_method(self) -> NoReturn:
+        raise PromiumException("Not implemented")
 
-    def __call__(self, driver):
+    def __call__(self, driver: Any) -> bool:
         if self.with_refresh:
             driver.refresh()
         return self.call_method()
 
 
 class ElementPresent(BaseElementConditionWithRefresh):
-
-    def call_method(self):
+    def call_method(self) -> bool:
         return bool(self.element.is_present())
 
 
@@ -27,8 +26,7 @@ is_present = ElementPresent
 
 
 class ElementNotPresent(BaseElementConditionWithRefresh):
-
-    def call_method(self):
+    def call_method(self) -> bool:
         return not self.element.is_present()
 
 
@@ -36,8 +34,7 @@ is_not_present = ElementNotPresent
 
 
 class ElementIsDisplay(BaseElementConditionWithRefresh):
-
-    def call_method(self):
+    def call_method(self) -> bool:
         return bool(self.element.is_displayed())
 
 
@@ -45,8 +42,7 @@ is_display = ElementIsDisplay
 
 
 class ElementNotDisplay(BaseElementConditionWithRefresh):
-
-    def call_method(self):
+    def call_method(self) -> bool:
         return not self.element.is_displayed()
 
 
@@ -54,12 +50,16 @@ is_not_display = ElementNotDisplay
 
 
 class ElementText(BaseElementConditionWithRefresh):
-
-    def __init__(self, element, text, with_refresh=False):
-        super(ElementText, self).__init__(element, with_refresh)
+    def __init__(
+        self,
+        element: Any,
+        text: str,
+        with_refresh: bool = False,
+    ) -> None:
+        super().__init__(element, with_refresh)
         self.text = text
 
-    def call_method(self):
+    def call_method(self) -> bool:
         return self.element.text == self.text
 
 
@@ -67,8 +67,7 @@ is_text = ElementText
 
 
 class ElementTextContain(ElementText):
-
-    def call_method(self):
+    def call_method(self) -> bool:
         return self.text in self.element.text
 
 
@@ -76,8 +75,7 @@ is_text_contain = ElementTextContain
 
 
 class ElementTextNotContain(ElementText):
-
-    def bool_method(self):
+    def call_method(self) -> bool:
         return self.text not in self.element.text
 
 

{promium-3.7.6 → promium-3.7.7}/promium/helpers.py

@@ -1,17 +1,15 @@
-
 from six.moves.urllib.parse import urlparse
 
 
-class ParseUrl(object):
-
-    def __init__(self, url):
+class ParseUrl:
+    def __init__(self, url: str) -> None:
         self.url = url
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return self.url
 
     @property
-    def scheme(self):
+    def scheme(self) -> str:
         """
         :return: scheme, for example: http or https
         """
@@ -19,57 +17,62 @@ class ParseUrl(object):
         return parse_url.scheme
 
     @property
-    def hostname(self):
+    def hostname(self) -> str:
         """
         :return: hostname, for example: prom.ua
         """
         parse_url = urlparse(self.url)
-        return parse_url.netloc.split(':')[0]
+        return parse_url.netloc.split(":")[0]
 
     @property
-    def port(self):
+    def port(self) -> str | None:
         """
         :return: port
         """
         parse_url = urlparse(self.url)
-        parse_netloc_split = parse_url.netloc.split(':')
+        parse_netloc_split = parse_url.netloc.split(":")
         if len(parse_netloc_split) > 1:
             return parse_netloc_split[-1]
+        return None
 
     @property
-    def path(self):
+    def path(self) -> str | None:
         """
         :return: hierarchical path, for example: /Zhenskii-platya
         """
         parse_url = urlparse(self.url)
         if parse_url.path:
             return parse_url.path
+        return None
 
     @property
-    def params(self):
+    def params(self) -> str | None:
         """
         :return: parameters for last path element
         """
         parse_url = urlparse(self.url)
         if parse_url.params:
             return parse_url.params
+        return None
 
     @property
-    def query(self):
+    def query(self) -> dict[str, str] | None:
         """
         :return: query component
         """
         parse_url = urlparse(self.url)
         if parse_url.query:
-            return dict(
-                [query.split('=') for query in parse_url.query.split('&')]
-            )
+            return dict([
+                query.split("=") for query in parse_url.query.split("&")
+            ])
+        return None
 
     @property
-    def fragment(self):
+    def fragment(self) -> str | None:
         """
         :return: fragment identifier (#)
         """
         parse_url = urlparse(self.url)
         if parse_url.fragment:
             return parse_url.fragment
+        return None

{promium-3.7.6 → promium-3.7.7}/promium/logger.py

@@ -6,13 +6,17 @@ import py
 import re
 from collections.abc import Callable
 from functools import wraps
-from typing import Any
+from typing import TYPE_CHECKING, Any, ParamSpec, TypeVar
 
 import allure
 import pytest
 from selenium.common.exceptions import WebDriverException
 
 
+P = ParamSpec("P")
+R = TypeVar("R")
+TCls = TypeVar("TCls", bound=type)
+
 log = logging.getLogger(__name__)
 
 MAX_SYMBOLS = 510
@@ -64,11 +68,11 @@ def find_console_browser_errors(driver: Any) -> set[str] | None:
         return set(browser_errors)
 
 
-def logger_for_element_methods(fn: Callable[..., Any]) -> Callable[..., Any]:
+def logger_for_element_methods[**P, R](fn: Callable[P, R]) -> Callable[P, R]:
     """Decorator for logging element method calls and console errors."""
 
     @wraps(fn)
-    def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
+    def wrapper(self: Any, *args: P.args, **kwargs: P.kwargs) -> R:
         res = fn(self, *args, **kwargs)
         console_errors = find_console_browser_errors(self.driver)
         is_check = os.environ.get("CHECK_CONSOLE")
@@ -106,13 +110,25 @@ def logger_for_element_methods(fn: Callable[..., Any]) -> Callable[..., Any]:
     return wrapper
 
 
-def add_logger_to_base_element_classes(cls: type[Any]) -> type[Any]:
-    """Decorate all public methods of a class with console logging."""
-    for name, method in cls.__dict__.items():
-        log.info(f"{name}, {method}")
-        if not name.startswith("_") and callable(method) and name != "lookup":
-            setattr(cls, name, logger_for_element_methods(method))
-    return cls
+if TYPE_CHECKING:
+
+    def add_logger_to_base_element_classes[TCls: type](cls: TCls) -> TCls:
+        """No-op for type checkers, зберігає видимість методів у IDE."""
+        return cls
+
+else:
+
+    def add_logger_to_base_element_classes[TCls: type](cls: TCls) -> TCls:
+        """Decorate all public methods of a class with console logging."""
+        for name, method in cls.__dict__.items():
+            log.info(f"{name}, {method}")
+            if (
+                not name.startswith("_")
+                and callable(method)
+                and name != "lookup"
+            ):
+                setattr(cls, name, logger_for_element_methods(method))
+        return cls
 
 
 def logger_for_loading_page(fn: Callable[..., Any]) -> Callable[..., Any]: