punit 1.5.3__tar.gz → 1.7.3__tar.gz

{punit-1.5.3/src/pUnit.egg-info → punit-1.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.5.3
+Version: 1.7.3
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License

{punit-1.5.3 → punit-1.7.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pUnit"
-version = "1.5.3"
+version = "1.7.3"
 description = "A modernized unit-test framework for Python."
 keywords = ["test", "unittest", "unit-test", "xUnit", "nUnit", "pytest"]
 authors = [

{punit-1.5.3 → punit-1.7.3/src/pUnit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.5.3
+Version: 1.7.3
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License

{punit-1.5.3 → punit-1.7.3}/src/pUnit.egg-info/SOURCES.txt

@@ -32,6 +32,12 @@ src/punit/reports/HtmlReportGenerator.py
 src/punit/reports/JUnitReportGenerator.py
 src/punit/reports/JsonReportGenerator.py
 src/punit/reports/__init__.py
+src/punit/setups/Setup.py
+src/punit/setups/SetupManager.py
+src/punit/setups/__init__.py
+src/punit/teardowns/Teardown.py
+src/punit/teardowns/TeardownManager.py
+src/punit/teardowns/__init__.py
 src/punit/theories/Theory.py
 src/punit/theories/TheoryManager.py
 src/punit/theories/__init__.py

{punit-1.5.3 → punit-1.7.3}/src/punit/TestResult.py

@@ -27,6 +27,22 @@ class TextIOCapture:
 
 
 class TestResult:
+    """
+    Accumulates the outcome of a single test execution.
+
+    Example
+    -------
+
+    Create and populate a result manually:
+
+    .. code-block:: python
+
+        result = TestResult()
+        result.module_name = 'tests.example'
+        result.test_name = 'test_something'
+        result.is_success = True
+
+    """
 
     __class_name: Optional[str]
     __exception: Exception | None
@@ -59,7 +75,11 @@ class TestResult:
 
     @property
     def class_name(self) -> Optional[str]:
-        return self.__class_name if self.__class_name is not None and len(self.__class_name) > 0 else None
+        return (
+            self.__class_name
+            if self.__class_name is not None and len(self.__class_name) > 0
+            else None
+        )
 
     @class_name.setter
     def class_name(self, value: Optional[str]) -> None:
@@ -171,15 +191,15 @@ class TestResult:
         elif took >= 0.000000001:
             return f'{(took*1000000):.3f}'.rstrip('0').rstrip('.') + 'μs'
         else:
-            return f'{(took*1000):.3f}'.rstrip('0').rstrip('.') + 'ms'
+            return f'{(took*1000000):.3f}'.rstrip('0').rstrip('.') + 'ns'
 
-    def captureOutput(self, quiet: bool = False) -> None:
+    def capture_output(self, quiet: bool = False) -> None:
         self.__stdout_capture = TextIOCapture(sys.stdout, quiet)
         self.__stderr_capture = TextIOCapture(sys.stderr, quiet)
         sys.stdout = self.__stdout_capture
         sys.stderr = self.__stderr_capture
 
-    def releaseOutput(self) -> None:
+    def release_output(self) -> None:
         if self.__stdout_capture is not None and self.__stdout_capture.target is not None:
             sys.stdout = self.__stdout_capture.target
         if self.__stderr_capture is not None and self.__stderr_capture.target is not None:

{punit-1.5.3 → punit-1.7.3}/src/punit/__init__.py

@@ -3,6 +3,8 @@
 
 from .assertions import collections, exceptions, numeric, strings
 from .facts import fact
+from .setups import Setup, setup
+from .teardowns import Teardown, teardown
 from .theories import theory, inlinedata
 from .traits import trait
 
@@ -10,8 +12,8 @@ from .assertions.exceptions import raises
 from .assertions.numeric import approx
 
 
-__version__ = '1.5.3'
-__commit__ = '34475af'
+__version__ = '1.7.3'
+__commit__ = 'a403690'
 __all__ = [
     '__version__', '__commit__',
     'assertions',
@@ -21,6 +23,8 @@ __all__ = [
     'strings',
     'fact',
     'metadata',
+    'setup', 'Setup',
+    'teardown', 'Teardown',
     'theory', 'inlinedata',
     'trait'
 ]

{punit-1.5.3 → punit-1.7.3}/src/punit/__main__.py

@@ -11,40 +11,42 @@ from .cli import CommandLineInterface
 from .discovery import TestModuleDiscovery
 from .reports import HtmlReportGenerator, JUnitReportGenerator, JsonReportGenerator
 from .runner import TestRunner
+from .setups.SetupManager import SetupManager
+from .teardowns.TeardownManager import TeardownManager
 
 
 async def async_main() -> None:
-    ts = time.time()
+    start_time = time.time()
     cli = CommandLineInterface.parse()
     if cli.help:  # pragma: no cover
-        cli.printHelp()
+        cli.print_help()
     elif cli.verbose and not cli.quiet:  # pragma: no cover
-        cli.printSummary()
+        cli.print_summary()
     elif not cli.quiet:  # pragma: no cover
-        cli.printVersion()
+        cli.print_version()
     os.chdir(cli.workdir)
     if cli.no_pathfix is not True:
-        pathbase = str(Path.cwd())
-        srcbase = os.path.join(pathbase, 'src')
-        if os.path.exists(srcbase) and srcbase not in sys.path:
-            sys.path.append(srcbase)
-        if pathbase not in sys.path:
-            sys.path.append(pathbase)
-    testModuleDiscovery = TestModuleDiscovery(
+        cwd_path = str(Path.cwd())
+        src_path = os.path.join(cwd_path, 'src')
+        if os.path.exists(src_path) and src_path not in sys.path:
+            sys.path.append(src_path)
+        if cwd_path not in sys.path:
+            sys.path.append(cwd_path)
+    test_module_discovery = TestModuleDiscovery(
         os.path.join(cli.workdir, cli.test_package_name),
         cli.includePatterns,
         cli.excludePatterns,
         cli)
-    testModuleDiscovery.discover()
-    testRunner = TestRunner(cli.test_package_name, testModuleDiscovery.filenames, cli)
-    results = await testRunner.run()
-    totalTime = time.time() - ts
-    failureCount = 0
+    test_module_discovery.discover()
+    test_runner = TestRunner(cli.test_package_name, test_module_discovery.filenames, cli)
+    results = await test_runner.run()
+    total_time = time.time() - start_time
+    failure_count = 0
     for result in results:
         if not result.is_success:
-            failureCount += 1  # pragma: no cover
+            failure_count += 1  # pragma: no cover
     if not cli.quiet:
-        print(f'Total: {len(results)}, Failures: {failureCount}, Took: {totalTime:.3f}s')
+        print(f'Total: {len(results)}, Failures: {failure_count}, Took: {total_time:.3f}s')
     if cli.reportFormat is not None:  # pragma: no cover
         report: str = ''
         match cli.reportFormat:
@@ -61,16 +63,25 @@ async def async_main() -> None:
                 with open(cli.outputFilename, 'wb') as file:
                     file.write(report.encode())
                 print(f'\n("{cli.reportFormat}" report written to: {cli.outputFilename})')
-    if failureCount > 0:
-        sys.stdout.flush()
-        sys.stderr.flush()
-        try:
-            os.fsync(sys.stdout.fileno())
-            os.fsync(sys.stderr.fileno())
-        except (AttributeError, ValueError, OSError):
-            # Pass if the stream doesn't support fsync (e.g. some virtualized environments)
-            pass
-        if cli.no_exitcode is not True:  # pragma: no cover
+
+    # not everyone runs python unbuffered as they should, so force a flush
+    sys.stdout.flush()
+    sys.stderr.flush()
+    try:
+        os.fsync(sys.stdout.fileno())
+        os.fsync(sys.stderr.fileno())
+    except (AttributeError, ValueError, OSError):
+        pass
+
+    if cli.no_exitcode is not True:
+        if failure_count:
+            # test failures trigger exit code 119 (for automation gating)
+            sys.exit(119)
+        if TeardownManager.instance().teardown_error_count > 0:
+            # teardown errors also trigger exit code 119 (for automation gating)
+            sys.exit(119)
+        if SetupManager.instance().setup_error_count > 0:
+            # setup errors also trigger exit code 119 (for automation gating)
             sys.exit(119)
 
 

{punit-1.5.3 → punit-1.7.3}/src/punit/assertions/numeric.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: © 2026 Shaun Wilson
 # SPDX-License-Identifier: MIT
 
+from __future__ import annotations
+
 from decimal import Decimal
 import math
 from typing import cast
@@ -397,7 +399,7 @@ class ApproxRangeComparator:
         self._abs_tol = abs_tol
         self._exclusive = False
 
-    def inclusive(self, flag: bool = True) -> 'ApproxRangeComparator':
+    def inclusive(self, flag: bool = True) -> ApproxRangeComparator:
         """
         Return a new ``ApproxRangeComparator`` with toggled inclusivity.
 
@@ -617,7 +619,7 @@ class approx:
         """Return a ``StrictLessThanComparator`` for strictly ``< expected`` (one-sided tolerance below)."""
         return StrictLessThanComparator(self._expected, self._rel_tol, self._abs_tol)
 
-    def in_range(self, min_val: float, max_val: float) -> 'ApproxRangeComparator':
+    def in_range(self, min_val: float, max_val: float) -> ApproxRangeComparator:
         """Return a comparator for ``[min_val, max_val]`` range checks with directional tolerance."""
         return ApproxRangeComparator(min_val, max_val, self._rel_tol, self._abs_tol)
 

{punit-1.5.3 → punit-1.7.3}/src/punit/cli.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: © 2024 Shaun Wilson
 # SPDX-License-Identifier: MIT
 
+from __future__ import annotations
+
 import os
 import sys
 from typing import Optional
@@ -10,6 +12,20 @@ from .traits import Trait
 
 
 class CommandLineInterface:
+    """
+    Command-line argument parser and display helper for pUnit.
+
+    Example
+    -------
+
+    Parse CLI arguments from ``sys.argv``:
+
+    .. code-block:: python
+
+        cli = CommandLineInterface.parse()
+        print(cli.test_package_name)
+
+    """
 
     __aliases: dict[str, str]
     __excludePatterns: list[str]
@@ -46,7 +62,13 @@ class CommandLineInterface:
         self.__workdir = os.path.curdir
         self.__verbose = False
 
-    def __parse(self, argv: list[str]) -> 'CommandLineInterface':
+    def __parse(self, argv: list[str]) -> CommandLineInterface:
+        """
+        Parse command-line arguments using a finite-state machine.
+
+        :param argv: List of argument strings (typically ``sys.argv``).
+        :returns: ``self`` for method chaining.
+        """
         aliasName: str | None = None
         extractFilter: bool = False
         extractExcludePattern: bool = False
@@ -158,7 +180,7 @@ class CommandLineInterface:
             FilterManager.instance().add(arg)
 
     @property
-    def aliases(self) -> dict:
+    def aliases(self) -> dict[str, str]:
         return self.__aliases
 
     @property
@@ -211,16 +233,15 @@ class CommandLineInterface:
 
     @property
     def no_exitcode(self) -> bool:
-        return self.__no_exitcode is True
+        return self.__no_exitcode
 
     @property
     def no_pathfix(self) -> bool:
-        return self.__no_pathfix is True
+        return self.__no_pathfix
 
-    def printHelp(self) -> None:
-        if True:  # pragma: no cover
-            self.printVersion()
-            print("""
+    def print_help(self) -> None:
+        self.print_version()
+        print("""
 Usage: python3 -m punit [-h|--help]
                         [-q|--quiet] [-v|--verbose]
                         [-z|--failfast]
@@ -279,10 +300,10 @@ Options:
         write to FILENAME. In this case `--report` does not
         suppress any program output.
 """)
-            os._exit(0)
+        os._exit(0)
 
-    def printSummary(self) -> None:
-        self.printVersion()
+    def print_summary(self) -> None:
+        self.print_version()
         print(f'Working Directory:\n\t{self.__workdir}')
         print(f'Fail Fast: \n\t{"Yes" if self.__failfast else "No"}')
         if len(self.__includePatterns) > 0:
@@ -295,7 +316,7 @@ Options:
                 print(f'\t{pattern}')
         FilterManager.instance().print()
 
-    def printVersion(self) -> None:
+    def print_version(self) -> None:
         print(f'pUnit {__version__} ({__commit__})')
 
     def validate(self) -> None:
@@ -314,7 +335,7 @@ Options:
             self.__excludePatterns.append('/__*__')
 
     @staticmethod
-    def parse(argv: list[str] = sys.argv) -> 'CommandLineInterface':
+    def parse(argv: list[str] = sys.argv) -> CommandLineInterface:
         result = CommandLineInterface().__parse(argv)
         result.validate()
         return result

{punit-1.5.3 → punit-1.7.3}/src/punit/facts/Fact.py

@@ -3,7 +3,7 @@
 
 import inspect
 from types import BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, ModuleType
-from typing import Callable, Coroutine, Union, cast
+from typing import Any, Callable, Coroutine, Union, cast
 
 from ..metadata import CallableMetadata
 
@@ -24,13 +24,14 @@ class Fact:
     def target(self) -> Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]:
         return self.__target
 
-    async def execute(self, module: ModuleType) -> None:
+    async def execute(self, module: ModuleType) -> Any | None:
+        class_instance: Any | None = None
         coro: Coroutine | None = None
         if hasattr(self.__target, '__qualname__') and self.__target.__qualname__.find('.') > -1:
             if isinstance(self.__target, staticmethod):
                 coro = self.__target()
             else:
-                qnparts = self.__target.__qualname__.split('.')
+                qnparts = [p for p in self.__target.__qualname__.split('.') if p != '<locals>']
                 qntarget = module
                 for qnpart in qnparts[0:-1]:
                     qntarget = getattr(qntarget, qnpart)
@@ -38,17 +39,26 @@ class Fact:
                     coro = self.__target.__func__(qntarget)
                 else:
                     # every test execution gets a new instance of class
-                    coro = self.__target(cast(Callable, qntarget)())
+                    class_instance = cast(Any, cast(Callable, qntarget)())
+                    coro = self.__target(class_instance)
         else:
             coro = self.__target()
         if inspect.iscoroutine(coro):
             await coro
+        return class_instance
 
 
 def fact(target: Callable) -> Callable:
     from .FactManager import FactManager
-    if (not inspect.isfunction(target)) and (not isinstance(target, classmethod)) and (not isinstance(target, staticmethod)):
+    unwrapped = inspect.unwrap(target)
+    if not isinstance(unwrapped, (FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType)):
         raise Exception('@fact can only be applied to functions and methods.')
+    if hasattr(unwrapped, '__punit_decorator'):
+        raise Exception(
+            f'@fact and {getattr(unwrapped, "__punit_decorator")} cannot decorate the same function. '
+            f'Function "{unwrapped.__name__}" has already been decorated.'
+        )
+    setattr(unwrapped, '__punit_decorator', '@fact')
     fact: Fact = Fact(target)
     FactManager.instance().put(fact)
     return target

{punit-1.5.3 → punit-1.7.3}/src/punit/facts/FactManager.py

@@ -2,6 +2,8 @@
 # SPDX-License-Identifier: MIT
 ##
 
+from __future__ import annotations
+
 from typing import Optional
 
 from ..filters.FilterManager import FilterManager
@@ -23,7 +25,7 @@ class FactManager:
         self.__modules = {}
 
     @staticmethod
-    def instance() -> 'FactManager':
+    def instance() -> FactManager:
         if FactManager.__instance is None:
             FactManager.__instance = FactManager()
         return FactManager.__instance

{punit-1.5.3 → punit-1.7.3}/src/punit/filters/Filter.py

@@ -5,17 +5,28 @@ import re
 
 
 class Filter:
+    """
+    Wraps a glob-style filter pattern and compiles it to a case-insensitive regex.
+
+    Patterns use ``*`` for multi-character wildcards and ``?`` for single characters.
+    Prefix with ``!`` to mark the filter as an exclusion rule.
+    """
 
     __isExclude: bool
     __pattern: str
-    __re: re.Pattern
+    __re: re.Pattern[str]
 
     def __init__(self, pattern: str) -> None:
         self.__isExclude = pattern.startswith('!')
         self.__pattern = pattern
         self.__re = self.__toRegex(pattern)
 
-    def __toRegex(self, pattern: str) -> re.Pattern:
+    def __toRegex(self, pattern: str) -> re.Pattern[str]:
+        """Convert a glob-style pattern to a compiled regex.
+
+        Supports ``*`` (multi-char wildcard), ``?`` (single-char wildcard),
+        and ``!`` prefix (exclusion).  Matching is case-insensitive.
+        """
         if self.__isExclude:
             pattern = pattern[1:]
         pattern = re.escape(pattern)\

{punit-1.5.3 → punit-1.7.3}/src/punit/filters/FilterManager.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: © 2026 Shaun Wilson
 # SPDX-License-Identifier: MIT
 
+from __future__ import annotations
+
 import os
 import select
 import sys
@@ -22,7 +24,7 @@ class FilterManager:
         return self.__filters
 
     @staticmethod
-    def instance() -> 'FilterManager':
+    def instance() -> FilterManager:
         instance = FilterManager.__instance
         if instance is None:
             instance = FilterManager()

{punit-1.5.3 → punit-1.7.3}/src/punit/metadata/CallableMetadata.py

@@ -14,7 +14,8 @@ class CallableMetadata:
 
     def __init__(self, callable: Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]) -> None:
         self.__callable = callable
-        self.__class_name = '.'.join(callable.__qualname__.replace(f'{callable.__module__}.', '').split('.')[0:-1])
+        parts = callable.__qualname__.replace(f'{callable.__module__}.', '').split('.')[0:-1]
+        self.__class_name = '.'.join(p for p in parts if p != '<locals>')
         self.__module_name = callable.__module__
         self.__name = callable.__name__
 

{punit-1.5.3 → punit-1.7.3}/src/punit/reports/JUnitReportGenerator.py

@@ -65,7 +65,7 @@ class JUnitTestSuite:
         result: int = 0
         if self.testCases is not None:
             for testCase in self.testCases:
-                if testCase.disabled == True:
+                if testCase.disabled is True:
                     result += 1
         return result
 
@@ -187,7 +187,7 @@ class JUnitReportGenerator:
                             ele.text = testCase.stderr
         testSuitesEle.attrib['disabled'] = str(totalDisabledCount)
         testSuitesEle.attrib['errors'] = str(totalErrorCount)
-        testSuitesEle.attrib['failures'] = str(totalErrorCount)
+        testSuitesEle.attrib['failures'] = str(totalFailureCount)
         testSuitesEle.attrib['tests'] = str(totalTestCount)
         testSuitesEle.attrib['time'] = f'{totalTime:.6f}'.rstrip('0').rstrip('.')
         et.indent(testSuitesEle, space="    ")