added logger decorator that takes from func doc string

Author: dmy.berezovskyi

core/driver.py

@@ -1,11 +1,9 @@
 import os
 from abc import ABC, abstractmethod
-
 from selenium import webdriver
 from selenium.webdriver.chrome.service import Service as ChromeService
 from selenium.webdriver.remote.remote_connection import RemoteConnection
 from webdriver_manager.chrome import ChromeDriverManager
-
 from core.driver_options import _init_driver_options
 from utils.error_handler import ErrorHandler, ErrorType
 from utils.logger import Logger, LogLevel
@@ -31,9 +29,9 @@ def _get_driver_path(driver_type=None):
 
 def _configure_driver(driver, environment):
     driver.maximize_window()
-    driver.implicitly_wait(15)
+    driver.implicitly_wait(3)
     driver.get(Properties.get_base_url(environment))
-    log.info(f"Local Chrome driver created with session: {driver}")
+    log.info(f"Configure driver and base url: {Properties.get_base_url(environment)}")
 
 
 class Driver(ABC):
@@ -43,28 +41,32 @@ def create_driver(self, environment, dr_type):
 
     def get_desired_caps(self, browser="chrome"):
         caps = YAMLReader.read_caps(browser)
-        log.info(f"capabilities for driver {caps}")
+        log.info(f"Capabilities for driver {caps}")
         return caps
 
 
 class LocalDriver(Driver):
-    def create_driver(self, environment=None, dr_type=None):
+    def create_driver(self, environment=None, dr_type="local"):
         """Tries to use ChromeDriverManager to install the latest driver,
         and if it fails, it falls back to a locally stored driver in resources."""
+        driver = None
         try:
-            log.info(f"Run local chrome driver with {_init_driver_options()}")
             driver_path = ChromeDriverManager().install()
+            options = _init_driver_options(dr_type=dr_type)
             driver = webdriver.Chrome(
                 service=ChromeService(executable_path=driver_path),
-                options=_init_driver_options(dr_type=dr_type))
+                options=options
+            )
+            log.info(
+                f"Created local Chrome driver with session: {driver.session_id}")
         except Exception as e:
-            log.info(f"Run local driver: {e}")
+            log.error(
+                f"Failed to create Chrome driver, falling back to local driver: {e}")
             driver = webdriver.Chrome(
                 service=ChromeService(_get_driver_path(dr_type)),
                 options=_init_driver_options(dr_type=dr_type),
             )
         _configure_driver(driver, environment)
-        log.info(f"Local Chrome driver created with session: {driver}")
         return driver
 
 
@@ -75,19 +77,23 @@ def create_driver(self, environment=None, dr_type=None):
             command_executor=RemoteConnection("your remote URL"),
             desired_capabilities={"LT:Options": caps},  # noqa
         )
-        log.info(f"Local Chrome driver created with session: {driver}")
+        log.info(
+            f"Remote Chrome driver created with session: {driver.session_id}")
         return driver
 
 
 class FirefoxDriver(Driver):
     def create_driver(self, environment=None, dr_type=None):
         try:
-            driver = webdriver.Firefox(options=_init_driver_options(dr_type))
+            driver = webdriver.Firefox(
+                options=_init_driver_options(dr_type=dr_type))
+            log.info(f"Created Firefox driver with session: {driver.session_id}")
         except Exception as e:
             driver = webdriver.Chrome(
                 service=ChromeService(_get_driver_path(dr_type)),
-                options=_init_driver_options(),
+                options=_init_driver_options(dr_type=dr_type),
             )
-            log.error(f"Run local firefox driver: {e}")
+            log.error(
+                f"Failed to create Firefox driver, falling back to Chrome: {e}")
         _configure_driver(driver, environment)
         return driver

core/driver_factory.py

@@ -4,7 +4,6 @@
 
 log = Logger(log_lvl=LogLevel.INFO).get_instance()
 
-
 class WebDriverFactory:
     DRIVER_MAPPING = {
         "chrome": ChromeRemoteDriver,
@@ -14,12 +13,10 @@ class WebDriverFactory:
 
     @staticmethod
     def create_driver(environment=None, driver_type="local"):
-        log.info(f"Creating driver {driver_type}")
+        log.info(f"Creating driver of type: {driver_type}")
         driver_type = driver_type.lower()
         if driver_type in WebDriverFactory.DRIVER_MAPPING:
             driver_class = WebDriverFactory.DRIVER_MAPPING[driver_type]
-            return driver_class().create_driver(environment, driver_type)
+            return driver_class().create_driver(environment, driver_type)  # No .value needed
         else:
-            raise ErrorHandler.raise_error(
-                ErrorType.ENV_ERROR, environment, driver_type
-            )
+            raise ErrorHandler.raise_error(ErrorType.ENV_ERROR, environment, driver_type)

core/driver_options.py

@@ -1,18 +1,16 @@
+import os
 import platform
-
 from selenium import webdriver
-
 from utils.logger import Logger, LogLevel
 from utils.error_handler import ErrorHandler, ErrorType
 
 log = Logger(log_lvl=LogLevel.INFO).get_instance()
 
 
 def _shared_driver_options(options):
-    # ... (options setup)
-    # options.add_argument("--headless")  # use headless with --no-sandbox
     options.add_argument("--start-maximized")
     options.add_argument("--disable-dev-shm-usage")
+    options.page_load_strategy = 'none' # disable waiting for fully load page
     if platform.system() == "Linux":
         options.add_argument("--no-sandbox")
     log.info(f"Driver options {options.arguments}")
@@ -28,9 +26,7 @@ def _init_driver_options(dr_type=None):
     options = driver_option_mapping.get(dr_type)
 
     if options is None:
-        raise ErrorHandler.raise_error(
-            ErrorType.UNSUPPORTED_DRIVER_TYPE, dr_type
-        )
+        raise ErrorHandler.raise_error(ErrorType.UNSUPPORTED_DRIVER_TYPE, dr_type)
 
     _shared_driver_options(options)
     log.info(f"Driver options {options.arguments}")

src/locators/locators.py

@@ -3,3 +3,7 @@
 
 class General:
     LOGO = (By.CLASS_NAME, "sj-logo lazy loaded")
+
+
+class TextFields:
+    USER_NAME = (By.ID, "userName")

src/pageobjects/base_page.py

@@ -8,6 +8,7 @@
     TimeoutException, ElementNotVisibleException
 )
 
+from utils.helpers import timing
 from utils.logger import log
 
 # Type alias for locators
@@ -45,18 +46,21 @@ def _get_waiter(self, wait_type: Optional[WaitType] = None) -> WebDriverWait:
             WaitType.FLUENT: self._fluent_wait,
         }.get(wait_type, self._wait)
 
+    @timing
     def wait_for(
         self,
         locator: Locator,
-        condition: Literal["clickable", "visible", "present"],
+        condition: Literal["clickable", "visible", "present"] = "visible",
         waiter: Optional[WebDriverWait] = None,
     ) -> WebElement:
+        """Wait for an element"""
         waiter = waiter or self._wait
 
         conditions = {
-            "clickable": EC.element_to_be_clickable(*locator),
-            "visible": EC.visibility_of_element_located(*locator),
-            "present": EC.presence_of_element_located(*locator),
+            "clickable": EC.element_to_be_clickable(locator),
+            # Pass the locator tuple as a single argument
+            "visible": EC.visibility_of_element_located(locator),
+            "present": EC.presence_of_element_located(locator),
         }
 
         if condition not in conditions:
@@ -83,17 +87,20 @@ def click(
         element = self.wait_for(locator, condition=condition, waiter=waiter)
         element.click()
 
+    # @log()
+    # @timing
     def set(
         self, locator: Locator, text: str, wait_type: Optional[WaitType] = None
     ):
         """
         Set text in an input field.
         """
         waiter = self._get_waiter(wait_type)
-        element = self.wait_for(locator, condition="visible", waiter=waiter)
+        element = self.wait_for(locator, waiter=waiter)
         element.clear()
         element.send_keys(text)
 
+    @log
     def get_text(
         self, locator: Locator, wait_type: Optional[WaitType] = None
     ) -> str:

src/pageobjects/text/fill_form.py

@@ -0,0 +1,10 @@
+from locators.locators import TextFields
+from pageobjects.base_page import BasePage
+from utils.logger import log, Logger
+
+
+class FillForm(BasePage):
+    @log()
+    def enter_username(self, name: str):
+        """Enter username"""
+        self.set(TextFields.USER_NAME, name)

tests/test_fill_form/test_fill_form.py

@@ -0,0 +1,8 @@
+from pageobjects.text.fill_form import FillForm
+
+
+class TestFillForm:
+
+    def test_fill_user(self, make_driver):
+        fill = FillForm(make_driver)
+        fill.enter_username("selenium framework")

utils/helpers.py

@@ -19,3 +19,16 @@ def wrapper(*args, **kwargs):
         return wrapper
 
     return decorator
+
+
+def timing(func):
+    """Perform a timing function"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
+        return result
+
+    return wrapper

utils/logger.py

@@ -64,28 +64,49 @@ def annotate(self, message: str, level: Literal["info", "warn", "debug", "error"
             raise ValueError(f"Invalid log level: {level}")
 
 
-def log(level: Literal["info", "warn", "debug", "error"] = "info") -> Callable:
+def log(
+    data: Optional[str] = None,
+    level: Literal["info", "warn", "debug", "error"] = "info"
+) -> Callable:
     """Decorator to log the current method's execution.
 
+    :param data: Custom log message to use if no docstring is provided.
     :param level: Level of the logs, e.g., info, warn, debug, error.
     """
     logger_instance = Logger()  # Get the singleton instance of Logger
 
     def decorator(func: Callable) -> Callable:
         def wrapper(self, *args, **kwargs) -> Any:
-            result = func(self, *args, **kwargs)
-            method_name = f" Method :: {func.__name__}()"
+            # Get the method's docstring
             method_docs = format_method_doc_str(func.__doc__)
 
-            logs = method_docs + method_name if method_docs else f"Executed {func.__name__}()"
+            # Raise an exception if both the docstring and data are None
+            if method_docs is None and data is None:
+                raise ValueError(
+                    f"No documentation available for method :: {func.__name__} and no custom log data provided."
+                )
+
+            # Construct the parameter string for logging
+            params_str = ', '.join(repr(arg) for arg in args)
+            kwargs_str = ', '.join(f"{k}={v!r}" for k, v in kwargs.items())
+            all_params_str = ', '.join(filter(None, [params_str, kwargs_str]))
+
+            # Log message with method documentation or custom data
+            logs = (method_docs + f" Method :: {func.__name__}()" + f" with parameters: {all_params_str}"
+                    if method_docs else
+                    data + f" Method :: {func.__name__}()" + f" with parameters: {all_params_str}")
+
             logger_instance.annotate(logs, level)
-            return result
+
+            # Call the original method, passing *args and **kwargs
+            return func(self, *args, **kwargs)  # <--- Fix: properly passing args and kwargs
 
         return wrapper
 
     return decorator
 
 
+
 def format_method_doc_str(doc_str: Optional[str]) -> Optional[str]:
     """Add a dot to the docs string if it doesn't exist."""
     if doc_str and not doc_str.endswith('.'):

utils/yaml_reader.py

@@ -139,7 +139,7 @@ def _flatten_values(
 
 
 # Example usage
-caps = YAMLReader.read_caps("chrome", "caps.yaml")
+# caps = YAMLReader.read_caps("chrome", "caps.yaml")
 # Example usage simple namespace
-simple = YAMLReader.read("data.yaml", to_simple_namespace=True)
-print(simple.users.username1)
+# simple = YAMLReader.read("data.yaml", to_simple_namespace=True)
+# print(simple.users.username1)