qa-testing-utils 0.0.9__tar.gz → 0.0.11__tar.gz

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.1
 Name: qa-testing-utils
-Version: 0.0.9
+Version: 0.0.11
 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.9 → qa_testing_utils-0.0.11}/pyproject.toml

@@ -3,7 +3,7 @@ distribution = true
 
 [tool.pdm.version]
 source = "scm"
-write_to = "qa_testing_utils/__init__.py"
+write_to = "qa_testing_utils/_version.py"
 write_template = "__version__ = '{}'"
 fallback_version = "0.0.0"
 
@@ -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.9"
+version = "0.0.11"
 
 [project.license]
 text = "Apache-2.0"

qa_testing_utils-0.0.11/src/qa_testing_utils/__init__.py

@@ -0,0 +1,88 @@
+# mkinit: start preserve
+from ._version import __version__  # isort: skip
+# mkinit: end preserve
+
+from qa_testing_utils.conftest_helpers import (
+    configure,
+    get_test_body,
+    makereport,
+)
+from qa_testing_utils.exception_utils import (
+    safely,
+    swallow,
+)
+from qa_testing_utils.exceptions import (
+    TestException,
+)
+from qa_testing_utils.file_utils import (
+    IterableReader,
+    crc32_of,
+    decompress_xz_stream,
+    extract_files_from_tar,
+    read_lines,
+    stream_file,
+    write_csv,
+)
+from qa_testing_utils.logger import (
+    Context,
+    LoggerMixin,
+    logger,
+    trace,
+)
+from qa_testing_utils.matchers import (
+    ContainsStringIgnoringCase,
+    IsIteratorYielding,
+    IsIteratorYieldingAll,
+    IsStreamContainingEvery,
+    IsWithinDates,
+    TracingMatcher,
+    adapted_iterator,
+    adapted_object,
+    adapted_sequence,
+    contains_string_ignoring_case,
+    match_as,
+    tracing,
+    within_dates,
+    yields_every,
+    yields_item,
+    yields_items,
+)
+from qa_testing_utils.object_utils import (
+    ImmutableMixin,
+    InvalidValueException,
+    SingletonBase,
+    SingletonMeta,
+    ToDictMixin,
+    Valid,
+    WithMixin,
+    classproperty,
+    require_not_none,
+    valid,
+)
+from qa_testing_utils.stream_utils import (
+    process_next,
+)
+from qa_testing_utils.string_utils import (
+    to_string,
+)
+from qa_testing_utils.thread_utils import (
+    ThreadLocal,
+    sleep_for,
+)
+from qa_testing_utils.tuple_utils import (
+    FromTupleMixin,
+)
+
+__all__ = ['ContainsStringIgnoringCase', 'Context', 'FromTupleMixin',
+           'ImmutableMixin', 'InvalidValueException', 'IsIteratorYielding',
+           'IsIteratorYieldingAll', 'IsStreamContainingEvery', 'IsWithinDates',
+           'IterableReader', 'LoggerMixin', 'SingletonBase', 'SingletonMeta',
+           'TestException', 'ThreadLocal', 'ToDictMixin', 'TracingMatcher',
+           'Valid', 'WithMixin', 'adapted_iterator', 'adapted_object',
+           'adapted_sequence', 'classproperty', 'configure',
+           'contains_string_ignoring_case', 'crc32_of', 'decompress_xz_stream',
+           'extract_files_from_tar', 'get_test_body', 'logger', 'makereport',
+           'match_as', 'process_next', 'read_lines', 'require_not_none',
+           'safely', 'sleep_for', 'stream_file', 'swallow', 'to_string',
+           'trace', 'tracing', 'valid', 'within_dates', 'write_csv',
+           'yields_every', 'yields_item', 'yields_items']

qa_testing_utils-0.0.11/src/qa_testing_utils/_version.py

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

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/src/qa_testing_utils/conftest_helpers.py

@@ -4,9 +4,8 @@
 
 import inspect
 import logging.config
-from pathlib import Path
 import sys
-from typing import Callable, Optional
+from pathlib import Path
 
 import pytest
 
@@ -15,6 +14,10 @@ def configure(config: pytest.Config,
               path: Path = Path(__file__).parent / "logging.ini") -> None:
     """
     Configures logging for pytest using a specified INI file, or defaults to internal logging.ini.
+
+    Args:
+        config (pytest.Config): The pytest configuration object.
+        path (Path, optional): Path to the logging configuration file. Defaults to 'logging.ini' in the current directory.
     """
     caller_module = inspect.getmodule(inspect.stack()[1][0])
     module_name = caller_module.__name__ if caller_module else "unknown"
@@ -28,6 +31,15 @@ def configure(config: pytest.Config,
 
 def makereport(
         item: pytest.Item, call: pytest.CallInfo[None]) -> pytest.TestReport:
+    """
+    Creates a pytest test report and appends the test body source code to the report sections.
+
+    Args:
+        item (pytest.Item): The pytest test item.
+        call (pytest.CallInfo[None]): The call information for the test.
+    Returns:
+        pytest.TestReport: The generated test report with the test body included.
+    """
     report = pytest.TestReport.from_item_and_call(item, call)
 
     if call.when == "call":
@@ -37,7 +49,15 @@ def makereport(
 
 
 def get_test_body(item: pytest.Item) -> str:
-    function: Optional[Callable[..., None]] = getattr(item, 'function', None)
+    """
+    Retrieves the source code of the test function for the given pytest item.
+
+    Args:
+        item (pytest.Item): The pytest test item.
+    Returns:
+        str: The source code of the test function, or an error message if unavailable.
+    """
+    function = getattr(item, 'function', None)
     if function is None:
         return "No function found for this test item."
 

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/src/qa_testing_utils/exception_utils.py

@@ -6,8 +6,8 @@ import functools
 import logging
 from typing import Any, Callable
 
-from returns.maybe import Maybe, Nothing, Some
 from qa_testing_utils.stream_utils import Supplier
+from returns.maybe import Maybe, Nothing, Some
 
 
 def safely[T](supplier: Supplier[T]) -> Maybe[T]:
@@ -24,8 +24,7 @@ def safely[T](supplier: Supplier[T]) -> Maybe[T]:
         Maybe[T]: The result wrapped in Maybe, or Nothing if an exception occurs.
     """
     try:
-        result = supplier()
-        return Some(result)
+        return Some(supplier())
     except Exception as e:
         logging.exception(f"Exception occurred: {e}")
         return Nothing

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/src/qa_testing_utils/file_utils.py

@@ -13,9 +13,9 @@ from zlib import crc32
 from more_itertools import peekable
 from qa_testing_utils.logger import *
 from qa_testing_utils.object_utils import *
-from qa_testing_utils.string_utils import *
+from qa_testing_utils.string_utils import DOT, EMPTY_BYTES, SPACE, UTF_8
 
-LAUNCHING_DIR = Path.cwd()
+LAUNCHING_DIR: Final[Path] = Path.cwd()
 
 
 @final

qa_testing_utils-0.0.11/src/qa_testing_utils/logger.py

@@ -0,0 +1,199 @@
+# SPDX-FileCopyrightText: 2025 Adrian Herscu
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+import logging
+from dataclasses import dataclass
+from functools import cached_property, wraps
+from typing import Callable, ClassVar, Final, 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
+@final
+class Context:
+    """Per-thread context for reporting and logging, allowing dynamic formatting of messages."""
+    _THREAD_LOCAL: ClassVar[ThreadLocal['Context']]
+    _formatter: Final[Callable[[str], str]]
+
+    @classmethod
+    def default(cls) -> "Context":
+        """
+        Returns a default Context instance with a no-op formatter.
+
+        Returns:
+            Context: A Context instance with the identity formatter.
+        """
+        return cls(lambda _: _)  # no formatter
+
+    @classproperty
+    def _format(cls) -> Callable[[str], str]:
+        return cls._THREAD_LOCAL.get()._formatter
+
+    @classmethod
+    def set(cls, context_fn: Callable[[str], str]) -> None:
+        """Sets per-thread context function to be used for formatting report and log messages."""
+        cls._THREAD_LOCAL.set(Context(context_fn))
+
+    @classmethod
+    def traced(cls, 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">>> "
+                             + cls._format(
+                                 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
+                    cls._format(
+                        f"{func.__name__} "
+                        f"{', '.join([str(arg) for arg in args[1:]])}")):
+                    result = func(*args, **kwargs)
+
+                if result == instance:
+                    logger.debug(f"<<< " + cls._format(f"{func.__name__}"))
+                else:
+                    logger.debug(
+                        f"<<< " + cls._format(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._THREAD_LOCAL = ThreadLocal(Context.default())  # 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 the decorated class.
+
+    Adds a `log` property to the class, providing a logger named after the class.
+    Useful for adding logging to any class without boilerplate.
+
+    Args:
+        cls (type): The class to decorate.
+
+    Returns:
+        type: The decorated class with a `log` property.
+    """
+    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:
+        """
+        Returns a logger named after the class.
+
+        Returns:
+            logging.Logger: The logger instance for this class.
+        """
+        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 to log.
+
+        Returns:
+            T: The value (unchanged).
+        """
+        self.log.debug(f"=== {value}")
+        return value

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/src/qa_testing_utils/matchers.py

@@ -3,20 +3,35 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from datetime import date, datetime
-from typing import (Any, Callable, Iterable, Iterator, List, Optional, Sequence,
-                    Union, cast, final, override)
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+    final,
+    override,
+)
 
 from hamcrest.core.base_matcher import BaseMatcher
 from hamcrest.core.description import Description
 from hamcrest.core.helpers.wrap_matcher import wrap_matcher
 from hamcrest.core.matcher import Matcher
-
 from qa_testing_utils.logger import LoggerMixin
 
 
 class TracingMatcher[T](BaseMatcher[T], LoggerMixin):
     """
     A matcher wrapper that adds debug logging around another matcher.
+
+    Logs the result of each match attempt using the class logger.
+
+    Args:
+        matcher (Matcher[T]): The matcher to wrap and trace.
     """
 
     def __init__(self, matcher: Matcher[T]) -> None:
@@ -31,17 +46,30 @@ class TracingMatcher[T](BaseMatcher[T], LoggerMixin):
         self._matcher.describe_to(description)
 
 
-def traced[T](matcher: Matcher[T]) -> TracingMatcher[T]:
+def tracing[T](matcher: Matcher[T]) -> TracingMatcher[T]:
     """
-    Wraps a matcher with TraceMatcher to enable debug logging.
+    Wraps a matcher with TracingMatcher to enable debug logging.
 
     Usage:
-        assert_that(actual, trace(contains_string("hello")))
+        assert_that(actual, traced(contains_string("hello")))
+
+    Args:
+        matcher (Matcher[T]): The matcher to wrap.
+    Returns:
+        TracingMatcher[T]: The wrapped matcher with tracing enabled.
     """
     return TracingMatcher(matcher)
 
 
+@final
 class ContainsStringIgnoringCase(BaseMatcher[str]):
+    """
+    Matcher that checks if a string contains a given substring, ignoring case.
+
+    Args:
+        substring (str): The substring to search for (case-insensitive).
+    """
+
     def __init__(self, substring: str) -> None:
         self.substring: str = substring.lower()
 
@@ -147,9 +175,10 @@ class IsIteratorYieldingAll[T](BaseMatcher[Iterator[T]]):
             description.append_description_of(matcher)
 
 
-DateOrDateTime = Union[date, datetime]
+type DateOrDateTime = Union[date, datetime]
 
 
+@final
 class IsWithinDates(BaseMatcher[DateOrDateTime]):
     def __init__(
             self, start_date: Optional[DateOrDateTime],
@@ -255,8 +284,7 @@ def yields_items[T](matches: Iterable[Union[Matcher[T],
     This matcher will iterate through the evaluated iterator and check if it yields
     at least one instance of each specified matcher or value.
     """
-    wrapped_matchers = [wrap_matcher(match) for match in matches]
-    return IsIteratorYieldingAll(wrapped_matchers)
+    return IsIteratorYieldingAll([wrap_matcher(match) for match in matches])
 
 
 def adapted_object[T, R](

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/src/qa_testing_utils/object_utils.py

@@ -5,8 +5,16 @@
 import threading
 from dataclasses import asdict, fields, is_dataclass, replace
 from enum import Enum
-from typing import (Any, Dict, Optional, Protocol,
-                    final, runtime_checkable, ClassVar)
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    Optional,
+    Protocol,
+    final,
+    runtime_checkable,
+)
 
 
 @runtime_checkable
@@ -158,6 +166,7 @@ class ToDictMixin:
         return flat_dict
 
 
+@final
 class SingletonMeta(type):
     """
     Thread-safe singleton metaclass.
@@ -200,16 +209,16 @@ class InvalidValueException(ValueError):
 
 def valid[T:Valid](value: T) -> T:
     """
-    Validates specified object, assuming that it supports the Valid protocol.
+    Validates the specified object, assuming it supports the Valid protocol.
 
     Args:
-        value (T:Valid): the object
+        value (T:Valid): The object to validate.
 
     Raises:
-        InvalidValueException: if the object is invalid
+        InvalidValueException: If the object is invalid (is_valid() returns False).
 
     Returns:
-        T:Valid: the validated object
+        T:Valid: The validated object if valid.
     """
     if value.is_valid():
         return value
@@ -227,12 +236,31 @@ def require_not_none[T](
         value (Optional[T]): The value to check for None.
         message (str, optional): The error message to use if value is None. Defaults to "Value must not be None".
 
-    Returns:
-        T: The value, guaranteed to be not None.
-
     Raises:
         ValueError: If value is None.
+
+    Returns:
+        T: The value, guaranteed to be not None.
     """
     if value is None:
         raise ValueError(message)
     return value
+
+
+@final
+class classproperty[T]:
+    """
+    Descriptor for defining class-level properties (like @property but for classes).
+
+    Example:
+        class MyClass:
+            @classproperty
+            def foo(cls):
+                return ...
+    """
+
+    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.9 → qa_testing_utils-0.0.11}/src/qa_testing_utils/stream_utils.py

@@ -4,7 +4,6 @@
 
 from typing import Callable, Iterator
 
-
 """
 A generic callable type alias representing a supplier of values of type T.
 

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/src/qa_testing_utils/string_utils.py

@@ -2,16 +2,16 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Callable, Type
+from typing import Callable, Final, Literal, Type
 
 from ppretty import ppretty  # type: ignore
 
-EMPTY_STRING = ""
-SPACE = " "
-DOT = "."
-LF = "\n"
-UTF_8 = "utf-8"
-EMPTY_BYTES = b''
+EMPTY_STRING: Final[str] = ""
+SPACE: Final[str] = " "
+DOT: Final[str] = "."
+LF: Final[str] = "\n"
+UTF_8: Final[str] = "utf-8"
+EMPTY_BYTES: Final[Literal[b'']] = b''
 
 
 def to_string[T](indent: str = '    ',

qa_testing_utils-0.0.11/src/qa_testing_utils/thread_utils.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: 2025 Adrian Herscu
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import concurrent.futures
+import time
+from datetime import timedelta
+from threading import local
+from typing import Final, Optional, cast
+
+COMMON_EXECUTOR: Final[concurrent.futures.ThreadPoolExecutor] = concurrent.futures.ThreadPoolExecutor()
+"""
+A shared thread pool executor for concurrent tasks across the application.
+"""
+
+
+def sleep_for(duration: timedelta):
+    """
+    Sleep for the specified duration.
+
+    Args:
+        duration (timedelta): The amount of time to sleep.
+    """
+    time.sleep(duration.total_seconds())
+
+
+class ThreadLocal[T]:
+    """
+    Thread-local storage for a value, with a default initializer.
+
+    Provides per-thread storage for a value of type T, initialized with a default.
+    """
+
+    def __init__(self, default: Optional[T] = None):
+        """
+        Initializes the thread-local storage with a default value.
+
+        Args:
+            default (Optional[T]): The default value for each thread, None if not specified.
+        """
+        self._local = local()
+        self._local.value = default
+
+    def set(self, value: T) -> None:
+        """
+        Sets the thread-local value for the current thread.
+
+        Args:
+            value (T): The value to set for the current thread.
+        """
+        self._local.value = value
+
+    def get(self) -> T:
+        """
+        Gets the thread-local value for the current thread.
+
+        Returns:
+            T: The value for the current thread.
+        """
+        return cast(T, self._local.value)

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/src/qa_testing_utils/tuple_utils.py

@@ -2,19 +2,34 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from dataclasses import is_dataclass, replace, fields
+from dataclasses import fields, is_dataclass, replace
 from typing import Any, Self, Tuple, Type
 
 
 class FromTupleMixin:
     """
-    Class decorator adding a `from_tuple` method allowing instantiation from
-    a tuple matching the order of decorated class fields.
+    Mixin that adds a `from_tuple` class method for instantiating objects from a tuple.
 
-    Works with frozen dataclasses too.
+    Allows creating an instance of a class (dataclass or regular class) by passing a tuple
+    whose values match the order of the class fields. Works with frozen dataclasses as well.
+
+    Example:
+        @dataclass(frozen=True)
+        class Point(FromTupleMixin):
+            x: int
+            y: int
+        p = Point.from_tuple((1, 2))
     """
     @classmethod
     def from_tuple(cls: Type[Self], data: Tuple[Any, ...]) -> Self:
+        """
+        Instantiates the class from a tuple of values, matching the order of class fields.
+
+        Args:
+            data (Tuple[Any, ...]): Tuple of values corresponding to the class fields.
+        Returns:
+            Self: An instance of the class with fields set from the tuple.
+        """
         if is_dataclass(cls):
             # Retrieve all fields, including inherited ones
             cls_fields = [f.name for f in fields(cls)]

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/tests/assertion_tests.py

@@ -7,7 +7,13 @@ from random import randint
 from typing import Callable
 
 import pytest
-from tenacity import Retrying, before_sleep_log, retry_if_exception_type, stop_after_attempt, wait_exponential
+from tenacity import (
+    Retrying,
+    before_sleep_log,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
 
 
 def unstable_function():

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/tests/file_utils_tests.py

@@ -1,5 +1,6 @@
 import csv
 from pathlib import Path
+
 from qa_testing_utils.file_utils import *
 
 
@@ -70,8 +71,9 @@ def should_decompress_xz_stream():
 
 
 def should_extract_files_from_tar():
-    import tarfile
     import io
+    import tarfile
+
     # Create a tar archive in memory
     file_content = b"testdata"
     tar_bytes = io.BytesIO()

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/tests/logger_tests.py

@@ -5,8 +5,8 @@
 from functools import wraps
 from typing import Callable, ParamSpec, Self, TypeVar
 
+from qa_pytest_rabbitmq.queue_handler import to_string
 from qa_testing_utils.logger import *
-from qa_testing_utils.string_utils import *
 
 
 def should_trace():
@@ -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.9 → qa_testing_utils-0.0.11}/tests/matchers_tests.py

@@ -8,11 +8,12 @@ from typing import Callable, Union
 import attr
 import pytest
 from functional import seq
-from hamcrest import all_of, assert_that, has_item, has_property, is_  # type: ignore -- seq
-from qa_testing_utils.string_utils import to_string
+from hamcrest import is_  # type: ignore
+from hamcrest import all_of, assert_that, has_item, has_property
 from qa_testing_utils.matchers import *
 from qa_testing_utils.object_utils import *
 from qa_testing_utils.string_utils import *
+from qa_testing_utils.string_utils import to_string
 
 
 @to_string()

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/tests/self_tests.py

@@ -2,18 +2,24 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from datetime import timedelta
 import random
+from datetime import timedelta
 from typing import Any, final
 
 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 *
+from hamcrest import assert_that, is_  # type: ignore
 from qa_testing_utils.exceptions import *
+from qa_testing_utils.logger import *
+from qa_testing_utils.logger import Context
 from qa_testing_utils.thread_utils import *
+from tenacity import (
+    before_sleep_log,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_fixed,
+)
 
 
 @final
@@ -28,7 +34,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.9 → qa_testing_utils-0.0.11}/tests/thread_utils_tests.py

@@ -2,9 +2,10 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import time
 from datetime import timedelta
+
 from qa_testing_utils.thread_utils import sleep_for
-import time
 
 
 def should_sleep_for_specified_duration():

qa_testing_utils-0.0.9/src/qa_testing_utils/__init__.py

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

qa_testing_utils-0.0.9/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

qa_testing_utils-0.0.9/src/qa_testing_utils/thread_utils.py

@@ -1,18 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Adrian Herscu
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import concurrent.futures
-import time
-from datetime import timedelta
-
-COMMON_EXECUTOR = concurrent.futures.ThreadPoolExecutor()
-
-
-def sleep_for(duration: timedelta):
-    """
-    Sleep for the specified duration.
-    Args:
-        duration (timedelta): The amount of time to sleep.
-    """
-    time.sleep(duration.total_seconds())

{qa_testing_utils-0.0.9 → qa_testing_utils-0.0.11}/tests/string_utils_tests.py

@@ -2,8 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from enum import Enum
 import logging
+from enum import Enum
 from typing import List
 
 from qa_testing_utils.string_utils import *