fix

Author: dmy.berezovskyi

core/driver.py

@@ -10,7 +10,7 @@
 from utils.error_handler import ErrorHandler, ErrorType
 from utils.logger import Logger, LogLevel
 from properties import Properties
-from utils.yaml_reader import YamlReader
+from utils.yaml_reader import YAMLReader
 
 log = Logger(log_lvl=LogLevel.INFO).get_instance()
 
@@ -42,7 +42,8 @@ def create_driver(self, environment, dr_type):
         pass
 
     def get_desired_caps(self, browser="chrome"):
-        caps = YamlReader.read_caps(browser)
+        caps = YAMLReader.read_caps(browser)
+        log.info(f"capabilities for driver {caps}")
         return caps
 
 
@@ -51,7 +52,7 @@ def create_driver(self, environment=None, dr_type=None):
         """Tries to use ChromeDriverManager to install the latest driver,
         and if it fails, it falls back to a locally stored driver in resources."""
         try:
-            log.info(f"Run local chrome driver")
+            log.info(f"Run local chrome driver with {_init_driver_options()}")
             driver_path = ChromeDriverManager().install()
             driver = webdriver.Chrome(
                 service=ChromeService(executable_path=driver_path),

src/pageobjects/base_page.py

@@ -8,6 +8,8 @@
     TimeoutException, ElementNotVisibleException
 )
 
+from utils.logger import log
+
 # Type alias for locators
 Locator = Tuple[By, str]
 
@@ -101,6 +103,7 @@ def get_text(
         waiter = self._get_waiter(wait_type)
         return self.wait_for(locator, condition="present", waiter=waiter).text
 
+    @log()
     def get_title(self) -> str:
         """
         Get the page title.

utils/helpers.py

@@ -0,0 +1,21 @@
+import time
+from functools import wraps
+
+
+def retry(retries=3, delay=2):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            attempts = 0
+            while attempts < retries:
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    attempts += 1
+                    print(f"Attempt {attempts} failed: {e}")
+                    time.sleep(delay)
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

utils/logger.py

@@ -2,6 +2,7 @@
 import os
 import time
 from enum import Enum
+from typing import Optional, Callable, Any, Literal
 
 
 class LogLevel(Enum):
@@ -14,41 +15,79 @@ class LogLevel(Enum):
 class Singleton(type):
     _instances = {}
 
-    def __call__(cls, *args, **kwargs):
+    def __call__(cls, *args, **kwargs) -> Any:
         if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(
-                *args, **kwargs
-            )
+            cls._instances[cls] = super().__call__(*args, **kwargs)
         return cls._instances[cls]
 
 
 class Logger(metaclass=Singleton):
-    def __init__(self, log_lvl=LogLevel.INFO):
+    def __init__(self, log_lvl: LogLevel = LogLevel.INFO) -> None:
         self._log = logging.getLogger("selenium")
         self._log.setLevel(LogLevel.DEBUG.value)
-
-        formatter = logging.Formatter(
-            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        )
         self.log_file = self._create_log_file()
-        self._configure_logging(log_lvl, formatter)
+        self._initialize_logging(log_lvl)
 
-    def _create_log_file(self):
+    def _create_log_file(self) -> str:
         current_time = time.strftime("%Y-%m-%d")
         log_directory = os.path.abspath(
-            os.path.join(os.path.dirname(__file__), "../tests", "logs")
-        )
+            os.path.join(os.path.dirname(__file__), "../tests/logs"))
 
-        if not os.path.exists(log_directory):
-            os.makedirs(log_directory)
+        try:
+            os.makedirs(log_directory, exist_ok=True)  # Create directory if it doesn't exist
+        except Exception as e:
+            raise RuntimeError(f"Failed to create log directory '{log_directory}': {e}")
 
         return os.path.join(log_directory, f"log_{current_time}.log")
 
-    def _configure_logging(self, log_lvl, formatter):
+    def _initialize_logging(self, log_lvl: LogLevel) -> None:
+        formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
         fh = logging.FileHandler(self.log_file, mode="w")
         fh.setFormatter(formatter)
         fh.setLevel(log_lvl.value)
         self._log.addHandler(fh)
 
-    def get_instance(self):
+    def get_instance(self) -> logging.Logger:
         return self._log
+
+    def annotate(self, message: str, level: Literal["info", "warn", "debug", "error"]) -> None:
+        """Log a message at the specified level."""
+        if level == "info":
+            self._log.info(message)
+        elif level == "warn":
+            self._log.warning(message)
+        elif level == "debug":
+            self._log.debug(message)
+        elif level == "error":
+            self._log.error(message)
+        else:
+            raise ValueError(f"Invalid log level: {level}")
+
+
+def log(level: Literal["info", "warn", "debug", "error"] = "info") -> Callable:
+    """Decorator to log the current method's execution.
+
+    :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__}()"
+            method_docs = format_method_doc_str(func.__doc__)
+
+            logs = method_docs + method_name if method_docs else f"Executed {func.__name__}()"
+            logger_instance.annotate(logs, level)
+            return result
+
+        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('.'):
+        return doc_str + "."
+    return doc_str