punit 1.9.2__tar.gz → 1.10.0__tar.gz

{punit-1.9.2/src/pUnit.egg-info → punit-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.9.2
+Version: 1.10.0
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License
@@ -36,7 +36,6 @@ Classifier: Intended Audience :: Developers
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: hazrakah
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: mypy; extra == "dev"

{punit-1.9.2 → punit-1.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pUnit"
-version = "1.9.2"
+version = "1.10.0"
 description = "A modernized unit-test framework for Python."
 keywords = ["test", "unittest", "unit-test", "xUnit", "nUnit", "pytest"]
 authors = [
@@ -16,7 +16,6 @@ classifiers = [
     "Intended Audience :: Developers"
 ]
 dependencies = [
-    "hazrakah"
 ]
 
 [project.optional-dependencies]

{punit-1.9.2 → punit-1.10.0/src/pUnit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.9.2
+Version: 1.10.0
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License
@@ -36,7 +36,6 @@ Classifier: Intended Audience :: Developers
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: hazrakah
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: mypy; extra == "dev"

{punit-1.9.2 → punit-1.10.0}/src/pUnit.egg-info/SOURCES.txt

@@ -28,6 +28,10 @@ src/punit/filters/FilterManager.py
 src/punit/filters/__init__.py
 src/punit/metadata/CallableMetadata.py
 src/punit/metadata/__init__.py
+src/punit/mocks/__init__.py
+src/punit/mocks/matcher.py
+src/punit/mocks/mock.py
+src/punit/mocks/patch.py
 src/punit/reports/HtmlReportGenerator.py
 src/punit/reports/JUnitReportGenerator.py
 src/punit/reports/JsonReportGenerator.py

{punit-1.9.2 → punit-1.10.0}/src/pUnit.egg-info/requires.txt

@@ -1,4 +1,3 @@
-hazrakah
 
 [dev]
 coverage

{punit-1.9.2 → punit-1.10.0}/src/punit/__init__.py

@@ -15,8 +15,8 @@ from .assertions.exceptions import raises
 from .assertions.numeric import approx
 
 
-__version__ = '1.9.2'
-__commit__ = '4f7d92b'
+__version__ = '1.10.0'
+__commit__ = '4e4c2b6'
 __all__ = [
     '__version__', '__commit__',
     'assertions',

punit-1.10.0/src/punit/mocks/__init__.py

@@ -0,0 +1,75 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+"""
+Provides :class:`Mock`, :class:`Matcher` argument matchers, a ``patch`` mechanism,
+and convenience functions.
+
+Usage::
+
+    from punit.mocks import Mock, mock, is_any, contains, patch
+
+    # Fluent syntax
+    mock = (
+        Mock()
+        .do_stuff.
+        returns(42)
+    )
+
+    # Constructor kwargs for fixture-style initialization
+    user = Mock(first_name='Alice', email='alice@example.com')
+    assert user.first_name == 'Alice'
+    assert user.email == 'alice@example.com'
+
+    # Matcher-based verification
+    assert mock.called_with(
+        is_any(),
+        neg(contains('foo')),
+        is_in(1, 2, 3))
+
+    # Module-level patching
+    with patch('some.module.ClassName') as m:
+        m.method.returns('result')
+"""
+
+from .matcher import (
+    Matcher,
+    neg,
+    contains,
+    is_any,
+    is_gte,
+    is_gt,
+    is_in,
+    is_lte,
+    is_lt,
+    is_type,
+)
+from .mock import (
+    CallDetail,
+    Call,
+    CallList,
+    CallRecord,
+    Mock,
+    MockError
+)
+from .patch import patch
+
+__all__ = [
+    'CallDetail',
+    'Call',
+    'CallList',
+    'CallRecord',
+    'Matcher',
+    'Mock',
+    'MockError',
+    'neg',
+    'contains',
+    'is_any',
+    'is_gte',
+    'is_gt',
+    'is_in',
+    'is_lte',
+    'is_lt',
+    'is_type',
+    'patch',
+]

punit-1.10.0/src/punit/mocks/matcher.py

@@ -0,0 +1,318 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+"""
+Argument matchers for Mock call verification.
+
+Matchers are lightweight, duck-typed objects that implement ``__eq__`` to dispatch
+matching logic. No :class:`typing.Protocol` is used -- any object with a working
+``__eq__`` method satisfies the matcher interface. This avoids needing a separate
+``.matches()`` API -- Python's equality operator dispatches naturally.
+
+Usage::
+
+    from punit.mocks import Mock, is_any, is_gt, is_in
+
+    mock = Mock()
+    mock(42, 'hello', ['a', 'b'])
+
+    assert mock.called_with(
+        is_gt(10),           # first arg > 10
+        is_any(),             # second arg can be anything
+        is_in('a', 'b'),     # third arg is 'a' or 'b'
+    )
+
+Custom matchers: subclass :class:`Matcher` and implement ``__eq__``::
+
+    class GreaterThan(Matcher):
+        def __init__(self, threshold: int) -> None:
+            self._threshold = threshold
+
+        def __eq__(self, other: object) -> bool:
+            return isinstance(other, (int, float)) and other > self._threshold
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class Matcher:
+    """Base class for argument matchers.
+
+    Subclasses must implement ``__eq__(self, other: Any) -> bool`` and return
+    ``True`` when *other* matches the expected pattern. This allows :meth:`Mock.called_with`
+    to dispatch via Python's equality operator naturally.
+    """
+
+
+class _IsAny(Matcher):
+    """Singleton matcher that matches any value."""
+
+    __slots__ = ()
+    _instance: '_IsAny | None' = None
+
+    def __new__(cls) -> '_IsAny':
+        if _IsAny._instance is None:
+            _IsAny._instance = super().__new__(cls)
+        return _IsAny._instance
+
+    def __eq__(self, other: Any) -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        return 'is_any'
+
+
+def is_any() -> Matcher:
+    """Return a singleton matcher that matches any single value.
+
+    :returns: A :class:`Matcher` instance.
+    """
+    return _IsAny()
+
+
+class _Contains(Matcher):
+    """Matcher that checks membership via the ``in`` operator."""
+
+    __slots__ = ('_value',)
+
+    def __init__(self, value: Any) -> None:
+        object.__setattr__(self, '_value', value)
+
+    @property
+    def value(self) -> Any:
+        return object.__getattribute__(self, '_value')
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, str):
+            return self._value in other  # type: ignore[operator, attr-defined]
+        try:
+            return self._value in other  # type: ignore[operator, attr-defined]
+        except TypeError:
+            return False
+
+    def __repr__(self) -> str:
+        return f'contains({self._value!r})'  # type: ignore[attr-defined]
+
+
+def contains(value: Any) -> Matcher:
+    """Return a matcher that checks if *value* is a substring of a string or
+    an element of a container (list, tuple, set, dict keys).
+
+    :param value: The value to search for.
+    :returns: A :class:`Matcher` instance.
+    """
+    return _Contains(value)
+
+
+class _IsGt(Matcher):
+    """Value is strictly greater than *n*."""
+
+    __slots__ = ('_value',)
+
+    def __init__(self, value: float) -> None:
+        object.__setattr__(self, '_value', value)
+
+    @property
+    def value(self) -> float:
+        return object.__getattribute__(self, '_value')
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, (int, float)) and other > self._value  # type: ignore[attr-defined]
+
+    def __repr__(self) -> str:
+        return f'is_gt({self._value!r})'  # type: ignore[attr-defined]
+
+
+def is_gt(n: float) -> Matcher:
+    """Return a matcher that checks if the value is strictly greater than *n*.
+
+    :param n: The threshold to compare against.
+    :returns: A :class:`Matcher` instance.
+    """
+    return _IsGt(n)
+
+
+class _IsGte(Matcher):
+    """Value is greater than or equal to *n*."""
+
+    __slots__ = ('_value',)
+
+    def __init__(self, value: float) -> None:
+        object.__setattr__(self, '_value', value)
+
+    @property
+    def value(self) -> float:
+        return object.__getattribute__(self, '_value')
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, (int, float)) and other >= self._value  # type: ignore[attr-defined]
+
+    def __repr__(self) -> str:
+        return f'is_gte({self._value!r})'  # type: ignore[attr-defined]
+
+
+def is_gte(n: float) -> Matcher:
+    """Return a matcher that checks if the value is greater than or equal to *n*.
+
+    :param n: The threshold to compare against.
+    :returns: A :class:`Matcher` instance.
+    """
+    return _IsGte(n)
+
+
+class _IsLt(Matcher):
+    """Value is strictly less than *n*."""
+
+    __slots__ = ('_value',)
+
+    def __init__(self, value: float) -> None:
+        object.__setattr__(self, '_value', value)
+
+    @property
+    def value(self) -> float:
+        return object.__getattribute__(self, '_value')
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, (int, float)) and other < self._value  # type: ignore[attr-defined]
+
+    def __repr__(self) -> str:
+        return f'is_lt({self._value!r})'  # type: ignore[attr-defined]
+
+
+def is_lt(n: float) -> Matcher:
+    """Return a matcher that checks if the value is strictly less than *n*.
+
+    :param n: The threshold to compare against.
+    :returns: A :class:`Matcher` instance.
+    """
+    return _IsLt(n)
+
+
+class _IsLte(Matcher):
+    """Value is less than or equal to *n*."""
+
+    __slots__ = ('_value',)
+
+    def __init__(self, value: float) -> None:
+        object.__setattr__(self, '_value', value)
+
+    @property
+    def value(self) -> float:
+        return object.__getattribute__(self, '_value')
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, (int, float)) and other <= self._value  # type: ignore[attr-defined]
+
+    def __repr__(self) -> str:
+        return f'is_lte({self._value!r})'  # type: ignore[attr-defined]
+
+
+def is_lte(n: float) -> Matcher:
+    """Return a matcher that checks if the value is less than or equal to *n*.
+
+    :param n: The threshold to compare against.
+    :returns: A :class:`Matcher` instance.
+    """
+    return _IsLte(n)
+
+
+class _IsIn(Matcher):
+    """Value equals one of the provided values."""
+
+    __slots__ = ('_values',)
+
+    def __init__(self, *values: Any) -> None:
+        object.__setattr__(self, '_values', tuple(values))
+
+    @property
+    def values(self) -> tuple[Any, ...]:
+        return object.__getattribute__(self, '_values')
+
+    def __eq__(self, other: Any) -> bool:
+        return other in self._values  # type: ignore[attr-defined]
+
+    def __repr__(self) -> str:
+        return f'is_in({self._values!r})'  # type: ignore[attr-defined]
+
+
+def is_in(*values: Any) -> Matcher:
+    """Return a matcher that checks if the value equals one of the provided values.
+
+    This is the inverse of :func:`contains` -- ``contains(x)`` checks if x is in the arg,
+    while ``is_in(a, b, c)`` checks if the arg is one of a, b, or c.
+
+    :param values: The candidate values to check against.
+    :returns: A :class:`Matcher` instance.
+    """
+    return _IsIn(*values)
+
+
+class _IsType(Matcher):
+    """Value is an instance of any given type(s)."""
+
+    __slots__ = ('_types',)
+
+    def __init__(self, *types: type) -> None:
+        object.__setattr__(self, '_types', tuple(types))
+
+    @property
+    def types(self) -> tuple[type, ...]:
+        return object.__getattribute__(self, '_types')
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, self._types)  # type: ignore[attr-defined]
+
+    def __repr__(self) -> str:
+        return f'is_type({self._types!r})'  # type: ignore[attr-defined]
+
+
+def is_type(*types: type) -> Matcher:
+    """Return a matcher that checks if the value is an instance of any given type(s).
+
+    :param types: One or more types to check against.
+    :returns: A :class:`Matcher` instance.
+    """
+    return _IsType(*types)
+
+
+class neg(Matcher):
+    """
+    Wraps another matcher and negates its result.
+
+    This enables composing matchers freely -- e.g. ``neg(is_in('admin', 'root'))``
+    matches any value that is not 'admin' or 'root'.
+
+    :param inner: The matcher to negate.
+    :returns: A :class:`Matcher` instance.
+    """
+
+    __slots__ = ('_inner',)
+
+    def __init__(self, inner: Matcher) -> None:
+        object.__setattr__(self, '_inner', inner)
+
+    @property
+    def inner(self) -> Matcher:
+        return object.__getattribute__(self, '_inner')
+
+    def __eq__(self, other: Any) -> bool:
+        return not self._inner.__eq__(other)  # type: ignore[attr-defined]
+
+    def __repr__(self) -> str:
+        return f'neg({self._inner!r})'  # type: ignore[attr-defined]
+
+
+__all__ = [
+    'Matcher',
+    'neg',
+    'is_any',
+    'contains',
+    'is_gt',
+    'is_gte',
+    'is_lt',
+    'is_lte',
+    'is_in',
+    'is_type',
+]