Version 2.3.3 (#72)

Author: VladimirPodolian

CHANGELOG.md

@@ -2,6 +2,20 @@
 
 <br>
 
+## v2.3.3
+*Release date: 2025-01-09*
+
+### Added
+- `dyatel.mixins/objects.driver.Driver` object
+
+### Changed
+- **Breaking:** `DriverWrapper` initialization now requires a `Driver` object
+- **Breaking:** Playwright's `context` and `page` creation have been moved out of `dyatel-wrapper`
+
+**Note:** Examples of the new logic can be found in the [ReadTheDocs documentation](https://dyatel-wrapper.readthedocs.io/getting_started.html#selenium-driver-setup)
+
+---
+
 ## v2.3.2
 *Release date: 2024-12-19*
 

docs/source/getting_started.md

@@ -71,11 +71,13 @@ class MainPage(Page):
 ```python
 import pytest  # noqa
 from selenium.webdriver.chrome.webdriver import WebDriver as ChromeWebDriver
+
 from dyatel.base.driver_wrapper import DriverWrapper
+from dyatel.mixins.objects.driver import Driver
 
 @pytest.fixture
 def driver_wrapper():
-    selenium_driver = ChromeWebDriver()
+    selenium_driver = Driver(driver=ChromeWebDriver())
     return DriverWrapper(selenium_driver)
 ```
 
@@ -87,17 +89,24 @@ def driver_wrapper():
 ```python
 import pytest  # noqa
 from appium.webdriver.webdriver import WebDriver as SourceAppiumDriver
+from appium.options.common.base import AppiumOptions
+
 from dyatel.base.driver_wrapper import DriverWrapper
+from dyatel.mixins.objects.driver import Driver
+
 
 @pytest.fixture
 def driver_wrapper():
     caps = {}  # Your device capabilities
     appium_ip, appium_port = None, None  # Your appium ip and port
+    options = AppiumOptions().load_capabilities(caps)
+    
     appium_driver = SourceAppiumDriver(
        command_executor=f'http://{appium_ip}:{appium_port}/wd/hub',
-       desired_capabilities=caps
+       options=options
     )
-    return DriverWrapper(appium_driver)
+    
+    return DriverWrapper(Driver(driver=appium_driver))
 ```
 
 ---
@@ -112,13 +121,18 @@ Dyatel Wrapper supports only sync API of playwright
 ```python
 import pytest  # noqa
 from playwright.sync_api import sync_playwright
+from dyatel.mixins.objects.driver import Driver
+
 from dyatel.base.driver_wrapper import DriverWrapper
 
 
 @pytest.fixture
 def driver_wrapper():
-    playwright_driver = sync_playwright().start().chromium.launch()
-    return DriverWrapper(playwright_driver)
+    instance = sync_playwright().start().chromium.launch()
+    context = instance.new_context()
+    page = context.new_page()
+    
+    return DriverWrapper(Driver(driver=page, context=context, instance=instance))
 ```
 
 ---

dyatel/__init__.py

@@ -1 +1 @@
-dyatel_version = '2.3.2'
+dyatel_version = '2.3.3'

dyatel/base/driver_wrapper.py

@@ -1,17 +1,14 @@
 from __future__ import annotations
 
-from typing import Union, Type, List, Tuple, Any, Optional
+from typing import Union, Type, List, Tuple, Any
 
 from PIL import Image
 from appium.webdriver.webdriver import WebDriver as AppiumDriver
 from selenium.webdriver.remote.webdriver import WebDriver as SeleniumDriver
-from playwright.sync_api import (
-    Browser as PlaywrightBrowser,
-    BrowserContext as PlaywrightContext,
-    Page as PlaywrightDriver,
-)
+from playwright.sync_api import Page as PlaywrightDriver
 
 from dyatel.mixins.objects.cut_box import CutBox
+from dyatel.mixins.objects.driver import Driver
 from dyatel.visual_comparison import VisualComparison
 from dyatel.abstraction.driver_wrapper_abc import DriverWrapperABC
 from dyatel.dyatel_play.play_driver import PlayDriver
@@ -81,6 +78,7 @@ class DriverWrapper(InternalMixin, Logging, DriverWrapperABC):
     _object = 'driver_wrapper'
     _base_cls: Type[PlayDriver, MobileDriver, WebDriver] = None
 
+    driver: Union[SeleniumDriver, AppiumDriver, PlaywrightDriver]
     session: DriverWrapperSessions = DriverWrapperSessions
 
     anchor = None
@@ -107,10 +105,6 @@ class DriverWrapper(InternalMixin, Logging, DriverWrapperABC):
 
     browser_name = None
 
-    driver: Union[SeleniumDriver, AppiumDriver, PlaywrightDriver]
-    instance: PlaywrightBrowser  # Only for playwright instance
-    context: PlaywrightContext  # Only for playwright instance
-
     def __new__(cls, *args, **kwargs):
         if cls.session.sessions_count() == 0:
             cls = super().__new__(cls)
@@ -133,23 +127,17 @@ def __repr__(self):
 
         return f'{cls.__name__}({self.label}={self.driver}) at {hex(id(self))}, platform={label}'
 
-    def __init__(
-            self,
-            driver: Union[PlaywrightBrowser, AppiumDriver, SeleniumDriver],
-            mobile_resolution: Optional[bool] = False,
-            *args,
-            **kwargs
-    ):
+    def __init__(self, driver: Driver):
         """
         Initializing of driver wrapper based on given driver source
 
         :param driver: appium or selenium or playwright driver to initialize
         """
-        self.driver = driver
+        self.__driver_container = driver
         self.session.add_session(self)
         self.label = f'{self.session.all_sessions.index(self) + 1}_driver'
-        self.__init_base_class__(*args, **kwargs)
-        if mobile_resolution:
+        self.__init_base_class__()
+        if driver.is_mobile_resolution:
             self.is_mobile_resolution = True
             self.is_desktop = False
             self.is_mobile = True
@@ -277,26 +265,28 @@ def soft_assert_screenshot(
 
         return True, f'No visual mismatch found for entire screen'
 
-    def __init_base_class__(self, *args, **kwargs) -> None:
+    def __init_base_class__(self) -> None:
         """
         Get driver wrapper class in according to given driver source, and set him as base class
 
         :return: None
         """
-        if isinstance(self.driver, PlaywrightBrowser):
+        source_driver = self.__driver_container.driver
+
+        if isinstance(source_driver, PlaywrightDriver):
             self.is_playwright = True
             self._base_cls = PlayDriver
-        elif isinstance(self.driver, AppiumDriver):
+        elif isinstance(source_driver, AppiumDriver):
             self.is_appium = True
             self._base_cls = MobileDriver
-        elif isinstance(self.driver, SeleniumDriver):
+        elif isinstance(source_driver, SeleniumDriver):
             self.is_selenium = True
             self._base_cls = WebDriver
         else:
             raise DriverWrapperException(f'Cant specify {self.__class__.__name__}')
 
         self._set_static(self._base_cls)
-        self._base_cls.__init__(self, driver=self.driver, *args, **kwargs)
+        self._base_cls.__init__(self, driver_container=self.__driver_container)
 
         for name, value in self.__dict__.items():
             setattr(self.__class__, name, value)

dyatel/dyatel_play/play_driver.py

@@ -2,37 +2,32 @@
 
 from typing import List, Union, Any
 
+from playwright._impl._errors import Error as PlaywrightError  # noqa
+
 from PIL import Image
 from playwright.sync_api import Locator, Page, Browser, BrowserContext
-from dyatel.dyatel_play.helpers.Trace import Trace
 
 from dyatel.abstraction.driver_wrapper_abc import DriverWrapperABC
+from dyatel.mixins.objects.driver import Driver
 from dyatel.shared_utils import get_image
 from dyatel.utils.internal_utils import get_timeout_in_ms, WAIT_UNIT
 from dyatel.utils.logs import Logging
 
 
 class PlayDriver(Logging, DriverWrapperABC):
 
-    instance: Browser
-    context: BrowserContext
-    driver: Page
-
-    def __init__(self, driver: Browser, trace: Trace = None, *args, **kwargs):
+    def __init__(self, driver_container: Driver):
         """
         Initializing of desktop web driver with playwright
 
-        :param driver: playwright driver to initialize
+        :param driver_container: Driver that contains playwright instance, context and driver objects
         """
         self.is_desktop = True
-        self.trace = trace
-        self.instance = driver
-        self.context = driver.new_context(*args, **kwargs)
 
-        if trace:
-            self.context.tracing.start(**trace.__dict__)
+        self.instance: Browser = driver_container.instance
+        self.context: BrowserContext = driver_container.context
+        self.driver: Page = driver_container.driver
 
-        self.driver = self.context.new_page()
         self.original_tab = self.driver
         self.browser_name = self.instance.browser_type.name
 
@@ -124,8 +119,11 @@ def quit(self, silent: bool = False, trace_path: str = 'trace.zip'):
         :param trace_path: Playwright only: path for the trace
         :return: None
         """
-        if self.trace and trace_path:
-            self.context.tracing.stop(path=trace_path)
+        if trace_path:
+            try:
+                self.context.tracing.stop(path=trace_path)
+            except PlaywrightError:
+                pass
 
         self.driver.close()
         self.context.close()

dyatel/dyatel_sel/driver/mobile_driver.py

@@ -13,13 +13,14 @@ class MobileDriver(CoreDriver):
 
     bundle_id: Optional[str]
 
-    def __init__(self, driver: AppiumDriver, *args, **kwargs):  # noqa
+    def __init__(self, driver_container: Driver, *args, **kwargs):  # noqa
         """
         Initializing of mobile driver with appium
 
-        :param driver: appium driver to initialize
+        :param driver_container: Driver that contains appium driver object
         """
-        self.caps = driver.capabilities
+        self.driver: AppiumDriver = driver_container.driver
+        self.caps = self.driver.capabilities
         self.browser_name = self.caps.get('browserName', None)
         self.is_web = bool(self.browser_name) or False
         self.is_app = self.caps.get('app', False)
@@ -39,7 +40,7 @@ def __init__(self, driver: AppiumDriver, *args, **kwargs):  # noqa
 
         self.native_safari = NativeSafari(self)
 
-        CoreDriver.__init__(self, driver=driver)
+        CoreDriver.__init__(self, driver=self.driver)
 
     def is_app_installed(self) -> bool:
         """

dyatel/dyatel_sel/driver/web_driver.py

@@ -3,21 +3,23 @@
 from selenium.webdriver.remote.webdriver import WebDriver as SeleniumWebDriver
 
 from dyatel.dyatel_sel.core.core_driver import CoreDriver
+from dyatel.mixins.objects.driver import Driver
 
 
 class WebDriver(CoreDriver):
 
-    def __init__(self, driver: SeleniumWebDriver, *args, **kwargs):  # noqa
+    def __init__(self, driver_container: Driver, *args, **kwargs):  # noqa
         """
         Initializing of desktop web driver with selenium
 
-        :param driver: selenium driver to initialize
+        :param driver_container: Driver that contains selenium driver object
         """
+        self.driver : SeleniumWebDriver = driver_container.driver
         self.is_desktop = True
-        self.original_tab = driver.current_window_handle
-        self.browser_name = driver.caps.get('browserName', None)
+        self.original_tab = self.driver.current_window_handle
+        self.browser_name = self.driver.caps.get('browserName', None)
 
-        CoreDriver.__init__(self, driver=driver)
+        CoreDriver.__init__(self, driver=self.driver)
 
     def set_window_size(self, width: int, height: int) -> CoreDriver:
         """

dyatel/mixins/objects/driver.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from typing import Union
+
+from appium.webdriver.webdriver import WebDriver as AppiumDriver
+from selenium.webdriver.remote.webdriver import WebDriver as SeleniumWebDriver
+from playwright.sync_api import (
+    Browser as PlaywrightBrowser,
+    BrowserContext as PlaywrightContext,
+    Page as PlaywrightDriver,
+)
+
+
+@dataclass
+class Driver:
+    driver: Union[AppiumDriver, SeleniumWebDriver, PlaywrightDriver]
+    context: Union[PlaywrightContext, None] = None
+    instance: Union[PlaywrightBrowser, None] = None
+    is_mobile_resolution: bool = False

tests/adata/drivers/appium_driver.py

@@ -1,6 +1,7 @@
 from appium.webdriver.webdriver import WebDriver as SourceAppiumDriver
 
 from dyatel.base.driver_wrapper import DriverWrapperSessions
+from dyatel.mixins.objects.driver import Driver
 from tests.adata.drivers.driver_entities import DriverEntities
 from tests.adata.drivers.selenium_driver import SeleniumDriver
 from tests.settings import android_desired_caps, ios_desired_caps
@@ -9,7 +10,7 @@
 class AppiumDriver:
 
     @staticmethod
-    def create_appium_driver(entities: DriverEntities):
+    def create_appium_driver(entities: DriverEntities) -> Driver:
         appium_ip = entities.config.getoption('--appium-ip')
         appium_port = entities.config.getoption('--appium-port')
         command_exc = f'http://{appium_ip}:{appium_port}/wd/hub'
@@ -24,4 +25,4 @@ def create_appium_driver(entities: DriverEntities):
         if DriverWrapperSessions.is_connected():
             return SeleniumDriver.create_selenium_driver(entities)
 
-        return SourceAppiumDriver(command_executor=command_exc, desired_capabilities=caps)
+        return Driver(driver=SourceAppiumDriver(command_executor=command_exc, desired_capabilities=caps))

tests/adata/drivers/driver_factory.py

@@ -1,3 +1,4 @@
+from dyatel.mixins.objects.driver import Driver
 from tests.adata.drivers.playwright_driver import PlaywrightDriver
 from tests.adata.drivers.appium_driver import AppiumDriver
 from tests.adata.drivers.driver_entities import DriverEntities
@@ -7,7 +8,7 @@
 class DriverFactory:
 
     @staticmethod
-    def create_driver(entities: DriverEntities):
+    def create_driver(entities: DriverEntities) -> Driver:
 
         is_mobile = entities.platform in ('ios', 'android')