pUnit 1.5.2__tar.gz → 1.7.2__tar.gz

{punit-1.5.2/src/pUnit.egg-info → punit-1.7.2}/PKG-INFO

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

{punit-1.5.2 → punit-1.7.2}/pyproject.toml

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

{punit-1.5.2 → punit-1.7.2/src/pUnit.egg-info}/PKG-INFO

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

{punit-1.5.2 → punit-1.7.2}/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.7.2/src/punit/TestResult.py

@@ -0,0 +1,190 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+import sys
+from typing import Any, TextIO, Optional, cast
+
+
+class TextIOCapture:
+
+    __quiet: bool
+    output: str | None = None
+    target: TextIO
+
+    def __init__(self, target: TextIO, quiet: bool = False) -> None:
+        self.__quiet = quiet
+        self.output = None
+        self.target = target
+
+    def write(self, text: str) -> int:
+        if self.output is None:
+            self.output = text
+        else:
+            self.output += text
+        if not self.__quiet:
+            self.target.write(text)
+        return len(text)
+
+
+class TestResult:
+
+    __class_name: Optional[str]
+    __exception: Exception | None
+    __file_name: str | None
+    __host_name: str | None
+    __is_success: bool | None
+    __module_name: str | None
+    __package_name: str | None
+    __properties: dict[str, Any]
+    __start_time: float | None
+    __stderr_capture: TextIOCapture | None
+    __stdout_capture: TextIOCapture | None
+    __stop_time: float | None
+    __test_name: str | None
+
+    def __init__(self) -> None:
+        self.__class_name = None
+        self.__exception = None
+        self.__file_name = None
+        self.__host_name = None
+        self.__is_success = None
+        self.__module_name = None
+        self.__package_name = None
+        self.__properties = dict[str, Any]()
+        self.__start_time = None
+        self.__stderr_capture = None
+        self.__stdout_capture = None
+        self.__stop_time = None
+        self.__test_name = None
+
+    @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
+        )
+
+    @class_name.setter
+    def class_name(self, value: Optional[str]) -> None:
+        self.__class_name = value
+
+    @property
+    def exception(self) -> Exception | None:
+        return self.__exception
+
+    @exception.setter
+    def exception(self, value: Exception) -> None:
+        self.__exception = value
+
+    @property
+    def file_name(self) -> str | None:
+        return self.__file_name
+
+    @file_name.setter
+    def file_name(self, value: str) -> None:
+        self.__file_name = value
+
+    @property
+    def host_name(self) -> str | None:
+        return self.__host_name
+
+    @host_name.setter
+    def host_name(self, value: str) -> None:
+        self.__host_name = value
+
+    @property
+    def is_success(self) -> bool:
+        return False if self.__is_success is None else self.__is_success
+
+    @is_success.setter
+    def is_success(self, value: bool) -> None:
+        self.__is_success = value
+
+    @property
+    def module_name(self) -> str:
+        return cast(str, self.__module_name)
+
+    @module_name.setter
+    def module_name(self, value: str) -> None:
+        self.__module_name = value
+
+    @property
+    def package_name(self) -> str | None:
+        return self.__package_name
+
+    @package_name.setter
+    def package_name(self, value: str) -> None:
+        self.__package_name = value
+
+    @property
+    def properties(self) -> dict[str, Any]:
+        return self.__properties
+
+    @properties.setter
+    def properties(self, value: dict[str, str]) -> None:
+        self.__properties = value
+
+    @property
+    def start_time(self) -> float | None:
+        return self.__start_time
+
+    @start_time.setter
+    def start_time(self, value: float) -> None:
+        self.__start_time = value
+
+    @property
+    def stderr(self) -> str | None:
+        return None if self.__stderr_capture is None else self.__stderr_capture.output
+
+    @property
+    def stdout(self) -> str | None:
+        return None if self.__stdout_capture is None else self.__stdout_capture.output
+
+    @property
+    def stop_time(self) -> float | None:
+        return self.__stop_time
+
+    @stop_time.setter
+    def stop_time(self, value: float) -> None:
+        self.__stop_time = value
+
+    @property
+    def test_name(self) -> str | None:
+        return self.__test_name
+
+    @test_name.setter
+    def test_name(self, value: str) -> None:
+        self.__test_name = value
+
+    @property
+    def took(self) -> float | None:
+        return None if self.__stop_time is None or self.__start_time is None else self.__stop_time - self.__start_time
+
+    @property
+    def tookPretty(self) -> str:
+        took = self.took
+        if took is None:
+            return 'N/A'
+        elif took >= 1:
+            return f'{took:.1f}'.rstrip('0').rstrip('.') + 's'
+        elif took >= 0.001:
+            return f'{(took*1000):.0f}ms'
+        elif took >= 0.000001:
+            return f'{(took*1000):.3f}'.rstrip('0').rstrip('.') + 'ms'
+        elif took >= 0.000000001:
+            return f'{(took*1000000):.3f}'.rstrip('0').rstrip('.') + 'μs'
+        else:
+            return f'{(took*1000):.3f}'.rstrip('0').rstrip('.') + 'ms'
+
+    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 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:
+            sys.stderr = self.__stderr_capture.target

{punit-1.5.2 → punit-1.7.2}/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.2'
-__commit__ = '19ca1ae'
+__version__ = '1.7.2'
+__commit__ = 'b60afab'
 __all__ = [
     '__version__', '__commit__',
     'assertions',
@@ -21,6 +23,8 @@ __all__ = [
     'strings',
     'fact',
     'metadata',
+    'setup', 'Setup',
+    'teardown', 'Teardown',
     'theory', 'inlinedata',
     'trait'
 ]

{punit-1.5.2 → punit-1.7.2}/src/punit/__main__.py

@@ -11,17 +11,19 @@ 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()
     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())
@@ -30,18 +32,18 @@ async def async_main() -> None:
             sys.path.append(srcbase)
         if pathbase not in sys.path:
             sys.path.append(pathbase)
-    testModuleDiscovery = TestModuleDiscovery(
-        os.path.join(cli.workdir, cli.testPackageName),
+    test_module_discovery = TestModuleDiscovery(
+        os.path.join(cli.workdir, cli.test_package_name),
         cli.includePatterns,
         cli.excludePatterns,
         cli)
-    testModuleDiscovery.discover()
-    testRunner = TestRunner(cli.testPackageName, testModuleDiscovery.filenames, cli)
+    test_module_discovery.discover()
+    testRunner = TestRunner(cli.test_package_name, test_module_discovery.filenames, cli)
     results = await testRunner.run()
     totalTime = time.time() - ts
     failureCount = 0
     for result in results:
-        if not result.isSuccess:
+        if not result.is_success:
             failureCount += 1  # pragma: no cover
     if not cli.quiet:
         print(f'Total: {len(results)}, Failures: {failureCount}, Took: {totalTime:.3f}s')
@@ -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 failureCount:
+            # 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.2 → punit-1.7.2}/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
@@ -79,7 +81,7 @@ def isclose(
         a_c = a if isinstance(a, complex) else complex(a, 0)
         b_c = b if isinstance(b, complex) else complex(b, 0)
         return math.isclose(a_c.real, b_c.real, rel_tol=rel_tol, abs_tol=abs_tol) and \
-               math.isclose(a_c.imag, b_c.imag, rel_tol=rel_tol, abs_tol=abs_tol)
+            math.isclose(a_c.imag, b_c.imag, rel_tol=rel_tol, abs_tol=abs_tol)
 
     # Both real: delegate to stdlib (safe float cast for int/float)
     return math.isclose(float(a), float(b), rel_tol=rel_tol, abs_tol=abs_tol)
@@ -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.2 → punit-1.7.2}/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
@@ -24,7 +26,7 @@ class CommandLineInterface:
     __outputFilename: Optional[str]
     __quiet: bool
     __reportFormat: Optional[str]
-    __testPackageName: str | None
+    __test_package_name: str | None
     __verbose: bool
     __workdir: str | None
 
@@ -42,11 +44,11 @@ class CommandLineInterface:
         self.__outputFilename = None
         self.__quiet = False
         self.__reportFormat = None
-        self.__testPackageName = 'tests'
+        self.__test_package_name = 'tests'
         self.__workdir = os.path.curdir
         self.__verbose = False
 
-    def __parse(self, argv: list[str]) -> 'CommandLineInterface':
+    def __parse(self, argv: list[str]) -> CommandLineInterface:
         aliasName: str | None = None
         extractFilter: bool = False
         extractExcludePattern: bool = False
@@ -92,8 +94,8 @@ class CommandLineInterface:
             elif self.__workdir is None:
                 self.__workdir = arg
                 continue
-            elif self.__testPackageName is None:
-                self.__testPackageName = arg
+            elif self.__test_package_name is None:
+                self.__test_package_name = arg
                 continue
             elif extractReportFormat:
                 extractReportFormat = False
@@ -122,7 +124,7 @@ class CommandLineInterface:
                 case '-z' | '--failfast':
                     self.__failfast = True
                 case '-p' | '--test-package':
-                    self.__testPackageName = None
+                    self.__test_package_name = None
                 case '-i' | '--include':
                     extractIncludePattern = True
                 case '-q' | '--quiet':
@@ -198,8 +200,8 @@ class CommandLineInterface:
         return self.__reportFormat
 
     @property
-    def testPackageName(self) -> str:
-        return 'tests' if self.__testPackageName is None else self.__testPackageName
+    def test_package_name(self) -> str:
+        return 'tests' if self.__test_package_name is None else self.__test_package_name
 
     @property
     def verbose(self) -> bool:
@@ -217,9 +219,9 @@ class CommandLineInterface:
     def no_pathfix(self) -> bool:
         return self.__no_pathfix is True
 
-    def printHelp(self) -> None:
+    def print_help(self) -> None:
         if True:  # pragma: no cover
-            self.printVersion()
+            self.print_version()
             print("""
 Usage: python3 -m punit [-h|--help]
                         [-q|--quiet] [-v|--verbose]
@@ -281,8 +283,8 @@ Options:
 """)
             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 +297,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:
@@ -307,14 +309,14 @@ Options:
             os._exit(2)
         self.__workdir = os.path.abspath(self.__workdir)
         if not self.__no_default_patterns:
-            # if no other patterns specified, default to including all files found in the directory matching `testPackageName`
+            # if no other patterns specified, default to including all files found in the directory matching `test_package_name`
             if len(self.__includePatterns) == 0:
                 self.__includePatterns.append('*.py')
             # always exclude dunder files
             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.2 → punit-1.7.2}/src/punit/discovery/TestModuleDiscovery.py

@@ -12,15 +12,15 @@ from ..traits import Trait
 
 class TestModuleDiscovery:
 
-    __cli:CommandLineInterface
-    __excludePatterns:list[re.Pattern]
-    __excludeTraits:list[Trait]
-    __filenames:list[str]
-    __includePatterns:list[re.Pattern]
-    __includeTraits:list[Trait]
-    __workdir:str
+    __cli: CommandLineInterface
+    __excludePatterns: list[re.Pattern]
+    __excludeTraits: list[Trait]
+    __filenames: list[str]
+    __includePatterns: list[re.Pattern]
+    __includeTraits: list[Trait]
+    __workdir: str
 
-    def __init__(self, workdir:str, includePatterns:list[str], excludePatterns:list[str], cli:CommandLineInterface) -> None:
+    def __init__(self, workdir: str, includePatterns: list[str], excludePatterns: list[str], cli: CommandLineInterface) -> None:
         self.__cli = cli
         self.__excludePatterns = []
         if excludePatterns is not None:
@@ -41,27 +41,26 @@ class TestModuleDiscovery:
                         re.IGNORECASE))
         self.__workdir = workdir
 
-
-    def __convertPatternToRegex(self, pattern:str) -> str:
+    def __convertPatternToRegex(self, pattern: str) -> str:
         result = re.escape(pattern)\
             .replace('\\\\', '/')\
             .replace('\\*', r'.*')\
             .replace('?', '.')
         return result
 
-    def __testAnyInclude(self, input:str) -> bool:
+    def __testAnyInclude(self, input: str) -> bool:
         for pat in self.__includePatterns:
             if len(pat.findall(input)) > 0:
                 return True
         return False
 
-    def __testAnyExclude(self, input:str) -> bool:
+    def __testAnyExclude(self, input: str) -> bool:
         for pat in self.__excludePatterns:
             if len(pat.findall(input)) > 0:
                 return True
         return False
 
-    def __walkDirectory(self, path:str) -> list[str]:
+    def __walkDirectory(self, path: str) -> list[str]:
         filenames = []
         if os.path.isdir(path):
             for dname, dlist, flist in os.walk(path, topdown=True):
@@ -97,7 +96,7 @@ class TestModuleDiscovery:
     @property
     def filenames(self) -> list[str]:
         return self.__filenames
-        
+
     def discover(self) -> list[str]:
         FactManager.instance().excludeTraits = self.__excludeTraits
         FactManager.instance().includeTraits = self.__includeTraits

{punit-1.5.2 → punit-1.7.2}/src/punit/facts/Fact.py

@@ -3,16 +3,16 @@
 
 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
 
 
 class Fact:
 
-    __target:Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]
+    __target: Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]
 
-    def __init__(self, target:Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]):
+    def __init__(self, target: Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]):
         self.__metadata = CallableMetadata(target)
         self.__target = target
 
@@ -24,14 +24,14 @@ class Fact:
     def target(self) -> Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]:
         return self.__target
 
-
-    async def execute(self, module:ModuleType) -> None:
-        coro:Coroutine|None = 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)
@@ -39,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:
+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.')
-    fact:Fact = Fact(target)
+    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