qa-testing-utils 0.0.8__tar.gz → 0.0.10__tar.gz

{qa_testing_utils-0.0.8 → qa_testing_utils-0.0.10}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.1
 Name: qa-testing-utils
-Version: 0.0.8
+Version: 0.0.10
 Summary: QA testing utilities
 Author-Email: Adrian Herscu <adrian.herscu@gmail.com>
 License: Apache-2.0
 Requires-Python: >=3.13
-Requires-Dist: pytest==8.3.5
+Requires-Dist: pytest==8.4.0
 Requires-Dist: PyHamcrest==2.1.0
 Requires-Dist: pyfunctional==1.5.0
 Requires-Dist: ppretty==1.3
-Requires-Dist: allure-pytest==2.14.2
+Requires-Dist: allure-pytest==2.14.3
 Requires-Dist: more-itertools==10.7.0
 Requires-Dist: returns==0.25.0
 Description-Content-Type: text/markdown

{qa_testing_utils-0.0.8 → qa_testing_utils-0.0.10}/pyproject.toml

@@ -23,15 +23,15 @@ authors = [
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
-    "pytest==8.3.5",
+    "pytest==8.4.0",
     "PyHamcrest==2.1.0",
     "pyfunctional==1.5.0",
     "ppretty==1.3",
-    "allure-pytest==2.14.2",
+    "allure-pytest==2.14.3",
     "more-itertools==10.7.0",
     "returns==0.25.0",
 ]
-version = "0.0.8"
+version = "0.0.10"
 
 [project.license]
 text = "Apache-2.0"

qa_testing_utils-0.0.10/src/qa_testing_utils/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.0.10'

qa_testing_utils-0.0.10/src/qa_testing_utils/logger.py

@@ -0,0 +1,177 @@
+# SPDX-FileCopyrightText: 2025 Adrian Herscu
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass
+import inspect
+import logging
+from functools import cached_property, wraps
+from typing import Callable, ClassVar, ParamSpec, TypeVar, cast, final
+
+import allure
+from qa_testing_utils.object_utils import classproperty
+from qa_testing_utils.string_utils import EMPTY_STRING, LF
+from qa_testing_utils.thread_utils import ThreadLocal
+
+P = ParamSpec('P')
+R = TypeVar('R')
+
+@dataclass
+class Context:
+    """Per-thread context for reporting and logging, allowing dynamic formatting of messages."""
+    _local: ClassVar[ThreadLocal['Context']]
+    _context_fn: Callable[[str], str]
+
+    @classproperty
+    def _apply(cls) -> Callable[[str], str]:
+        return Context._local.get()._context_fn
+
+    @staticmethod
+    def set(context_fn: Callable[[str], str]) -> None:
+        """Sets per-thread context function to be used for formatting report and log messages."""
+        return Context._local.set(Context(context_fn))
+    
+    @staticmethod
+    def traced(func: Callable[P, R]) -> Callable[P, R]:
+        """
+        Decorator to log function entry, arguments, and return value at DEBUG level.
+
+        Also adds an Allure step for reporting. Use on methods where tracing is useful
+        for debugging or reporting.
+
+        Example:
+            @Context.traced
+            def my_method(self, x):
+                ...
+
+        Args:
+            func (Callable[P, R]): The function to be decorated.
+            *args (Any): Positional arguments to be passed to the function.
+            **kwargs (Any): Keyword arguments to be passed to the function.
+
+        Returns:
+            Callable[P, R]: The result of the function call.
+        """
+        @wraps(func)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            # NOTE: each time a decorated function is called this logic will be
+            # re-evaluated.
+            signature = inspect.signature(func)
+            parameters = list(signature.parameters.keys())
+
+            if parameters and parameters[0] == 'self' and len(args) > 0:
+                instance = args[0]
+                logger = logging.getLogger(f"{instance.__class__.__name__}")
+                logger.debug(f">>> "
+                    + Context._apply(
+                        f"{func.__name__} "
+                        f"{", ".join([str(arg) for arg in args[1:]])} "
+                        f"{LF.join(
+                            f"{key}={str(value)}"
+                            for key, value in kwargs.items()) if kwargs else EMPTY_STRING}"))
+
+                with allure.step(  # type: ignore
+                    Context._apply(
+                        f"{func.__name__} "
+                        f"{', '.join([str(arg) for arg in args[1:]])}")):
+                    result = func(*args, **kwargs)
+
+                if result == instance:
+                    logger.debug(f"<<< " + Context._apply(f"{func.__name__}"))
+                else:
+                    logger.debug(f"<<< " + Context._apply(f"{func.__name__} {result}"))
+
+                return result
+            else:
+                logger = logging.getLogger(func.__name__)
+                logger.debug(f">>> {func.__name__} {args} {kwargs}")
+                result = func(*args, **kwargs)
+                logger.debug(f"<<< {func.__name__} {result}")
+                return result
+
+        return wrapper
+
+
+# NOTE: python does not support static initializers, so we init here.
+Context._local = ThreadLocal(Context(lambda _: _)) # type: ignore
+
+def trace[T](value: T) -> T:
+    """Logs at debug level using the invoking module name as the logger."""
+    frame = inspect.currentframe()
+    try:
+        if frame is not None:
+            caller_frame = frame.f_back
+            if caller_frame is not None:
+                caller_module = inspect.getmodule(caller_frame)
+                logger_name = caller_module.__name__ if caller_module else '__main__'
+                logger = logging.getLogger(logger_name)
+                logger.debug(f"=== {value}")
+            else:
+                logging.getLogger(__name__).debug(f"=== {value}")
+        else:
+            logging.getLogger(__name__).debug(f"=== {value}")
+    finally:
+        del frame
+
+    return value
+
+
+def logger[T:type](cls: T) -> T:
+    """
+    Class decorator that injects a logger into annotated class.
+
+    Args:
+        cls (type): automatically provided by the runtime
+
+    Returns:
+        _type_: the decorated class
+    """
+    cls._logger = logging.getLogger(cls.__name__)
+
+    @property
+    def log(self: T) -> logging.Logger:
+        return cast(logging.Logger, getattr(self, '_logger', None))
+
+    cls.log = log
+
+    return cls
+
+
+class LoggerMixin:
+    """
+    Mixin that provides a `log` property for convenient class-based logging.
+
+    Inherit from this mixin to get a `self.log` logger named after the class.
+    Useful for adding debug/info/error logging to any class without boilerplate.
+
+    Example:
+        class MyClass(LoggerMixin):
+            def do_something(self):
+                self.log.info("Doing something")
+    """
+    @final
+    @cached_property
+    def log(self) -> logging.Logger:
+        return logging.getLogger(self.__class__.__name__)
+
+    @final
+    def trace[T](self, value: T) -> T:
+        """
+        Logs value at DEBUG level using this logger.
+
+        Use to log something as a value, usually in a lambda expression::
+
+            then.eventually_assert_that(
+                lambda: self.trace(...call some API...),
+                greater_that(0)) \
+
+                .and_....other verifications may follow...
+
+        Args:
+            value (T): the value
+
+        Returns:
+            T: the value
+        """
+        self.log.debug(f"=== {value}")
+        return value

{qa_testing_utils-0.0.8 → qa_testing_utils-0.0.10}/src/qa_testing_utils/object_utils.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from typing import Callable, Any
 import threading
 from dataclasses import asdict, fields, is_dataclass, replace
 from enum import Enum
@@ -236,3 +237,11 @@ def require_not_none[T](
     if value is None:
         raise ValueError(message)
     return value
+
+
+class classproperty[T]:
+    def __init__(self, fget: Callable[[Any], T]) -> None:
+        self.fget = fget
+
+    def __get__(self, instance: Any, owner: Any) -> T:
+        return self.fget(owner)

{qa_testing_utils-0.0.8 → qa_testing_utils-0.0.10}/src/qa_testing_utils/thread_utils.py

@@ -3,8 +3,10 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import concurrent.futures
+from threading import local
 import time
 from datetime import timedelta
+from typing import cast
 
 COMMON_EXECUTOR = concurrent.futures.ThreadPoolExecutor()
 
@@ -16,3 +18,15 @@ def sleep_for(duration: timedelta):
         duration (timedelta): The amount of time to sleep.
     """
     time.sleep(duration.total_seconds())
+
+
+class ThreadLocal[T]:
+    def __init__(self, default: T):
+        self._local = local()
+        self._local.value = default
+
+    def set(self, value: T) -> None:
+        self._local.value = value
+
+    def get(self) -> T:
+        return cast(T, self._local.value)

{qa_testing_utils-0.0.8 → qa_testing_utils-0.0.10}/tests/logger_tests.py

@@ -17,7 +17,7 @@ def should_trace():
 
     @to_string()
     class Foo(LoggerMixin):
-        @traced
+        @Context.traced
         def run(self, message: Message) -> Self:
             self.log.debug(f"{message}")
             return self
@@ -85,7 +85,7 @@ def should_return_value_and_log_with_logger_mixin_trace():
 def should_log_entry_and_exit_with_traced_decorator():
     calls: list[tuple[int, int]] = []
 
-    @traced
+    @Context.traced
     def foo(x: int, y: int) -> int:
         calls.append((x, y))
         return x + y

{qa_testing_utils-0.0.8 → qa_testing_utils-0.0.10}/tests/self_tests.py

@@ -10,7 +10,7 @@ import attr
 from hamcrest import assert_that, is_  # type: ignore
 import pytest
 from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_fixed
-from qa_testing_utils.logger import traced
+from qa_testing_utils.logger import Context
 from qa_testing_utils.logger import *
 from qa_testing_utils.exceptions import *
 from qa_testing_utils.thread_utils import *
@@ -28,7 +28,7 @@ class SelfTests(LoggerMixin):
         """Test that print statement works (placeholder/self-test)."""
         print("hello")
 
-    @traced
+    @Context.traced
     def should_assert_true(self):
         """Test that a traced assertion passes (decorator coverage)."""
         assert True

qa_testing_utils-0.0.8/src/qa_testing_utils/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.0.8'

qa_testing_utils-0.0.8/src/qa_testing_utils/logger.py

@@ -1,155 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Adrian Herscu
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import inspect
-import logging
-from functools import cached_property, wraps
-from typing import Callable, ParamSpec, TypeVar, cast, final
-
-import allure
-from qa_testing_utils.string_utils import EMPTY_STRING, LF
-
-
-def trace[T](value: T) -> T:
-    """Logs at debug level using the invoking module name as the logger."""
-    frame = inspect.currentframe()
-    try:
-        if frame is not None:
-            caller_frame = frame.f_back
-            if caller_frame is not None:
-                caller_module = inspect.getmodule(caller_frame)
-                logger_name = caller_module.__name__ if caller_module else '__main__'
-                logger = logging.getLogger(logger_name)
-                logger.debug(f"=== {value}")
-            else:
-                logging.getLogger(__name__).debug(f"=== {value}")
-        else:
-            logging.getLogger(__name__).debug(f"=== {value}")
-    finally:
-        del frame
-
-    return value
-
-
-def logger[T:type](cls: T) -> T:
-    """
-    Class decorator that injects a logger into annotated class.
-
-    Args:
-        cls (type): automatically provided by the runtime
-
-    Returns:
-        _type_: the decorated class
-    """
-    cls._logger = logging.getLogger(cls.__name__)
-
-    @property
-    def log(self: T) -> logging.Logger:
-        return cast(logging.Logger, getattr(self, '_logger', None))
-
-    cls.log = log
-
-    return cls
-
-
-class LoggerMixin:
-    """
-    Mixin that provides a `log` property for convenient class-based logging.
-
-    Inherit from this mixin to get a `self.log` logger named after the class.
-    Useful for adding debug/info/error logging to any class without boilerplate.
-
-    Example:
-        class MyClass(LoggerMixin):
-            def do_something(self):
-                self.log.info("Doing something")
-    """
-    @final
-    @cached_property
-    def log(self) -> logging.Logger:
-        return logging.getLogger(self.__class__.__name__)
-
-    @final
-    def trace[T](self, value: T) -> T:
-        """
-        Logs value at DEBUG level using this logger.
-
-        Use to log something as a value, usually in a lambda expression::
-
-            then.eventually_assert_that(
-                lambda: self.trace(...call some API...),
-                greater_that(0)) \
-
-                .and_....other verifications may follow...
-
-        Args:
-            value (T): the value
-
-        Returns:
-            T: the value
-        """
-        self.log.debug(f"=== {value}")
-        return value
-
-
-P = ParamSpec('P')
-R = TypeVar('R')
-
-
-def traced(func: Callable[P, R]) -> Callable[P, R]:
-    """
-    Decorator to log function entry, arguments, and return value at DEBUG level.
-
-    Also adds an Allure step for reporting. Use on methods where tracing is useful
-    for debugging or reporting.
-
-    Example:
-        @traced
-        def my_method(self, x):
-            ...
-
-    Args:
-        func (Callable[P, R]): The function to be decorated.
-        *args (Any): Positional arguments to be passed to the function.
-        **kwargs (Any): Keyword arguments to be passed to the function.
-
-    Returns:
-        Callable[P, R]: The result of the function call.
-    """
-    @wraps(func)
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-        # NOTE: each time a decorated function is called this logic will be
-        # re-evaluated.
-        signature = inspect.signature(func)
-        parameters = list(signature.parameters.keys())
-
-        if parameters and parameters[0] == 'self' and len(args) > 0:
-            instance = args[0]
-            logger = logging.getLogger(f"{instance.__class__.__name__}")
-            logger.debug(
-                f">>> {func.__name__} "
-                f"{", ".join([str(arg) for arg in args[1:]])} "
-                f"{LF.join(
-                    f"{key}={str(value)}"
-                    for key, value in kwargs.items()) if kwargs else EMPTY_STRING}")
-
-            with allure.step(  # type: ignore
-                    f"{func.__name__} "
-                    f"{', '.join([str(arg) for arg in args[1:]])}"):
-                result = func(*args, **kwargs)
-
-            if result == instance:
-                logger.debug(f"<<< {func.__name__}")
-            else:
-                logger.debug(f"<<< {func.__name__} {result}")
-
-            return result
-        else:
-            logger = logging.getLogger(func.__name__)
-            logger.debug(f">>> {func.__name__} {args} {kwargs}")
-            result = func(*args, **kwargs)
-            logger.debug(f"<<< {func.__name__} {result}")
-            return result
-
-    return wrapper