punit 1.4.9__tar.gz → 1.5.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.4.9
+Version: 1.5.3
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License
@@ -114,7 +114,7 @@ Options:
         Default: '*.py'
     -e, --exclude PATTERN
         Exclude test files matching PATTERN, overriding --include
-        Default: '__*__' (dunder files), '/.*/' (dot-directories)
+        Default: '__*__' (dunders)
     -f, --filter PATTERN|@FILEPATH
         Only execute tests matching PATTERN
         Default: '*'

{punit-1.4.9 → punit-1.5.3}/README.md

@@ -70,7 +70,7 @@ Options:
         Default: '*.py'
     -e, --exclude PATTERN
         Exclude test files matching PATTERN, overriding --include
-        Default: '__*__' (dunder files), '/.*/' (dot-directories)
+        Default: '__*__' (dunders)
     -f, --filter PATTERN|@FILEPATH
         Only execute tests matching PATTERN
         Default: '*'

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.4.9
+Version: 1.5.3
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License
@@ -114,7 +114,7 @@ Options:
         Default: '*.py'
     -e, --exclude PATTERN
         Exclude test files matching PATTERN, overriding --include
-        Default: '__*__' (dunder files), '/.*/' (dot-directories)
+        Default: '__*__' (dunders)
     -f, --filter PATTERN|@FILEPATH
         Only execute tests matching PATTERN
         Default: '*'

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

@@ -16,6 +16,7 @@ src/punit/runner.py
 src/punit/assertions/__init__.py
 src/punit/assertions/collections.py
 src/punit/assertions/exceptions.py
+src/punit/assertions/numeric.py
 src/punit/assertions/strings.py
 src/punit/discovery/TestModuleDiscovery.py
 src/punit/discovery/__init__.py

punit-1.5.3/src/punit/TestResult.py

@@ -0,0 +1,186 @@
+# 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 captureOutput(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:
+        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.3/src/punit/__init__.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from .assertions import collections, exceptions, numeric, strings
+from .facts import fact
+from .theories import theory, inlinedata
+from .traits import trait
+
+from .assertions.exceptions import raises
+from .assertions.numeric import approx
+
+
+__version__ = '1.5.3'
+__commit__ = '34475af'
+__all__ = [
+    '__version__', '__commit__',
+    'assertions',
+    'collections',
+    'exceptions', 'raises',
+    'numeric', 'approx',
+    'strings',
+    'fact',
+    'metadata',
+    'theory', 'inlinedata',
+    'trait'
+]

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

@@ -31,17 +31,17 @@ async def async_main() -> None:
         if pathbase not in sys.path:
             sys.path.append(pathbase)
     testModuleDiscovery = TestModuleDiscovery(
-        os.path.join(cli.workdir, cli.testPackageName),
+        os.path.join(cli.workdir, cli.test_package_name),
         cli.includePatterns,
         cli.excludePatterns,
         cli)
     testModuleDiscovery.discover()
-    testRunner = TestRunner(cli.testPackageName, testModuleDiscovery.filenames, cli)
+    testRunner = TestRunner(cli.test_package_name, testModuleDiscovery.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')

{punit-1.4.9 → punit-1.5.3}/src/punit/assertions/__init__.py

@@ -1,11 +1,12 @@
 # SPDX-FileCopyrightText: © 2024 Shaun Wilson
 # SPDX-License-Identifier: MIT
 
-from . import collections, exceptions, strings
+from . import collections, exceptions, numeric, strings
 
 
 __all__ = [
     'collections',
     'exceptions',
+    'numeric',
     'strings'
 ]

{punit-1.4.9 → punit-1.5.3}/src/punit/assertions/collections.py

@@ -4,12 +4,14 @@
 from typing import Any, Callable, Optional, Sequence, cast
 
 
-def areSame(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None, expected: Sequence[Any] | set[Any] | dict[Any, Any] | None, sort: bool = False, sort_function: Optional[Callable[[Any], Any]] = None) -> bool:
+def are_same(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None, expected: Sequence[Any] | set[Any] | dict[Any, Any] | None, sort: bool = False, sort_function: Optional[Callable[[Any], Any]] = None) -> bool:
     """
     Check if two sequences contain the same elements in the same order.
-    
-    :param actual: The sequence to check
-    :param expected: The sequence to compare against
+
+    Can optionally specify *sort* so that differences in order do not cause failure.
+
+    :param actual: The sequence to check.
+    :param expected: The sequence to compare against.
     :param sort: Sort sequences before performing comparisons.
     :param sort_function: Custom function to use when sorting.
     :returns bool: True if the sequences contain the same elements in the same order, False otherwise.
@@ -27,44 +29,48 @@ def areSame(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None, expected:
         if sort:
             if isinstance(actual, dict) or isinstance(expected, dict):
                 sort_function = sort_function if sort_function is not None else lambda e: e[0]
-                actual = sorted(cast(dict, actual).items(), key=sort_function)
-                expected = sorted(cast(dict, expected).items(), key=sort_function)
+                actual = sorted(cast(dict[Any, Any], actual).items(), key=sort_function)
+                expected = sorted(cast(dict[Any, Any], expected).items(), key=sort_function)
             else:
                 sort_function = sort_function if sort_function is not None else lambda e: e
                 actual = sorted(actual, key=sort_function)
                 expected = sorted(expected, key=sort_function)
 
         if isinstance(actual, dict) or isinstance(expected, dict):
-            for pairs in zip(cast(dict, actual).items(), cast(dict, expected).items()):
+            for pairs in zip(cast(dict[Any, Any], actual).items(), cast(dict[Any, Any], expected).items()):
                 if not areSame(pairs[0], pairs[1]):
-                    return False            
+                    return False
         else:
             for pairs in zip(actual, expected):
                 if isinstance(pairs[0], dict) or isinstance(pairs[1], dict):
                     if not areSame(pairs[0], pairs[1]):
-                        return False            
-                elif pairs[0] != pairs[1]:
                         return False
+                elif pairs[0] != pairs[1]:
+                    return False
     return True
 
-def hasLength(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None, expected: int | None) -> bool:
+
+def has_length(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None, min: Optional[int] = None, max: Optional[int] = None) -> bool:
     """
     Check if actual value has the expected number of elements.
-    
+
     :param actual: The actual value to check.
     :param int|None expected: The expected number of elements
-        
+
     :returns bool: True if the sequence has exactly the expected number of elements, False otherwise
     """
-    if actual is None and (expected is None or expected == 0):
-        return True
-    elif actual is None and (expected is not None and expected != 0):
-        return False
-    elif actual is not None and expected is None:
-        return False
-    return actual is not None and len(actual) == expected
+    if actual is None:
+        if ((min is None or min == 0) and (max is None or max == 0)):
+            return True
+        return not ((min is not None and min != 0) or (max is not None or max != 0))
+    else:
+        if ((min is None) and (max is None)):
+            return False
+        len_actual = len(actual)
+        return (min is None or len_actual >= min) and (max is None or len_actual <= max)
+
 
-def isNoneOrEmpty(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None) -> bool:
+def is_none_or_empty(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None) -> bool:
     """
     Check if actual value is None or empty.
 
@@ -74,3 +80,20 @@ def isNoneOrEmpty(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None) -> b
     if actual is None:
         return True
     return len(actual) == 0
+
+
+# DEPRECATIONS
+areSame = are_same
+hasLength = has_length
+isNoneOrEmpty = is_none_or_empty
+
+
+__all__ = [
+    'are_same',
+    'has_length',
+    'is_none_or_empty',
+    # deprecated (do not use):
+    'areSame',
+    'hasLength',
+    'isNoneOrEmpty'
+]

{punit-1.4.9 → punit-1.5.3}/src/punit/assertions/exceptions.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
 # SPDX-License-Identifier: MIT
 
 from typing import Any, Callable, Generic, Optional, TypeVar, cast, get_args
@@ -8,12 +8,12 @@ TError = TypeVar('TError', bound=Exception)
 
 
 class raises(Generic[TError]):
-    
-    __action:Callable
-    __exact:bool
-    __expect:Optional[TError|type]
 
-    def __init__(self, action:Callable, *, exact:bool = False, expect:Optional[TError|type] = None) -> None:
+    __action: Callable[[], Any]
+    __exact: bool
+    __expect: Optional[TError | type]
+
+    def __init__(self, action: Callable[[], Any], *, exact: bool = False, expect: Optional[TError | type] = None) -> None:
         self.__action = action
         self.__exact = exact
         self.__expect = expect
@@ -28,7 +28,7 @@ class raises(Generic[TError]):
             if self.__exact:
                 return type(ex) is expected
             elif expected is not None:
-                return issubclass(type(ex), cast(Any,expected))
+                return issubclass(type(ex), cast(Any, expected))
         return False