pUnit 1.2.0__py3-none-any.whl

punit/TestResult.py

@@ -0,0 +1,186 @@
+# SPDX-FileCopyrightText: © 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):
+        if self.output is None:
+            self.output = text
+        else:
+            self.output += text
+        if not self.__quiet:
+            self.target.write(text)
+
+
+class TestResult:
+
+    __className:Optional[str]
+    __exception:Exception|None
+    __fileName:str|None
+    __hostName:str|None
+    __isSuccess:bool|None
+    __moduleName:str|None
+    __packageName:str|None
+    __properties:dict[str, Any]
+    __startTime:float|None
+    __stderrCapture:TextIOCapture|None
+    __stdoutCapture:TextIOCapture|None
+    __stopTime:float|None
+    __testName:str|None
+
+    def __init__(self):
+        self.__className = None
+        self.__exception = None
+        self.__fileName = None
+        self.__hostName = None
+        self.__isSuccess = None
+        self.__moduleName = None
+        self.__packageName = None
+        self.__properties = dict[str,Any]()
+        self.__startTime = None
+        self.__stderrCapture = None
+        self.__stdoutCapture = None
+        self.__stopTime = None
+        self.__testName = None
+
+    @property
+    def className(self) -> Optional[str]:
+        return self.__className
+    
+    @className.setter
+    def className(self, value:Optional[str]) -> None:
+        self.__className = value
+
+    @property
+    def exception(self) -> Exception|None:
+        return self.__exception
+    
+    @exception.setter
+    def exception(self, value:Exception) -> None:
+        self.__exception = value
+
+    @property
+    def fileName(self) -> str|None:
+        return self.__fileName
+    
+    @fileName.setter
+    def fileName(self, value:str) -> None:
+        self.__fileName = value
+
+    @property
+    def hostName(self) -> str|None:
+        return self.__hostName
+    
+    @hostName.setter
+    def hostName(self, value:str) -> None:
+        self.__hostName = value
+
+    @property
+    def isSuccess(self) -> bool:
+        return False if self.__isSuccess is None else self.__isSuccess
+    
+    @isSuccess.setter
+    def isSuccess(self, value:bool) -> None:
+        self.__isSuccess = value
+
+    @property
+    def moduleName(self) -> str:
+        return cast(str,self.__moduleName)
+    
+    @moduleName.setter
+    def moduleName(self, value:str) -> None:
+        self.__moduleName = value
+
+    @property
+    def packageName(self) -> str|None:
+        return self.__packageName
+    
+    @packageName.setter
+    def packageName(self, value:str) -> None:
+        self.__packageName = 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 startTime(self) -> float|None:
+        return self.__startTime
+    
+    @startTime.setter
+    def startTime(self, value:float) -> None:
+        self.__startTime = value
+
+    @property
+    def stderr(self) -> str|None:
+        return None if self.__stderrCapture is None else self.__stderrCapture.output
+
+    @property
+    def stdout(self) -> str|None:
+        return None if self.__stdoutCapture is None else self.__stdoutCapture.output
+
+    @property
+    def stopTime(self) -> float|None:
+        return self.__stopTime
+    
+    @stopTime.setter
+    def stopTime(self, value:float) -> None:
+        self.__stopTime = value
+
+    @property
+    def testName(self) -> str|None:
+        return self.__testName
+    
+    @testName.setter
+    def testName(self, value:str) -> None:
+        self.__testName = value
+
+    @property
+    def took(self) -> float|None:
+        return None if self.__stopTime is None or self.__startTime is None else self.__stopTime - self.__startTime
+
+    @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.__stdoutCapture = TextIOCapture(sys.stdout, quiet)
+        self.__stderrCapture = TextIOCapture(sys.stderr, quiet)
+        sys.stdout = self.__stdoutCapture
+        sys.stderr = self.__stderrCapture
+
+    def releaseOutput(self) -> None:
+        if self.__stdoutCapture is not None and self.__stdoutCapture.target is not None:
+            sys.stdout = self.__stdoutCapture.target
+        if self.__stderrCapture is not None and self.__stderrCapture.target is not None:
+            sys.stderr = self.__stderrCapture.target

punit/__init__.py

@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: © Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+__version__ = '1.2.0'
+
+from .assertions import *
+from .facts import *
+from .theories import *
+from .traits import *
+
+
+__all__ = [
+    'assertions',
+    'collections', 'exceptions', 'strings',
+    'facts',
+    'fact',
+    'theories',
+    'theory', 'inlinedata',
+    'traits',
+    'trait'
+]

punit/__main__.py

@@ -0,0 +1,59 @@
+# SPDX-FileCopyrightText: © Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+import asyncio
+import os
+import time
+from .cli import CommandLineInterface
+from .discovery import TestModuleDiscovery
+from .reports import HtmlReportGenerator, JUnitReportGenerator
+from .runner import TestRunner
+
+
+async def async_main():
+    ts = time.time()
+    cli = CommandLineInterface.parse()
+    if cli.help:
+        cli.printHelp()
+    elif cli.verbose and not cli.quiet:
+        cli.printSummary()
+    elif not cli.quiet:
+        cli.printVersion()
+    os.chdir(cli.workdir)
+    testModuleDiscovery = TestModuleDiscovery(
+        os.path.join(cli.workdir, cli.testPackageName),
+        cli.includePatterns,
+        cli.excludePatterns,
+        cli)
+    testModuleDiscovery.discover()
+    testRunner = TestRunner(cli.testPackageName, testModuleDiscovery.filenames, cli)
+    results = await testRunner.run()
+    totalTime = time.time() - ts
+    failureCount = 0
+    for result in results:
+        if not result.isSuccess:
+            failureCount += 1
+    if not cli.quiet:
+        print(f'Total: {len(results)}, Failures: {failureCount}, Took: {totalTime:.3f}s')
+    if cli.reportFormat is not None:
+        report:str|None = None
+        match cli.reportFormat:
+            case 'html':
+                report = HtmlReportGenerator().generate(results)
+            case 'junit':
+                report = JUnitReportGenerator().generate(results)
+        if report is not None:
+            if cli.outputFilename is None:
+                print(report)
+            else:
+                with open(cli.outputFilename, 'wb') as file:
+                    file.write(report.encode())
+                print(f'\n("{cli.reportFormat}" report written to: {cli.outputFilename})')
+    if failureCount > 0:
+        exit(119)
+
+def main():
+    asyncio.run(async_main())
+
+if (__name__ == '__main__'):
+    main()

punit/assertions/__init__.py

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

punit/assertions/collections.py

@@ -0,0 +1,76 @@
+# SPDX-FileCopyrightText: © Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from typing import Any, Callable, Sequence, Optional, cast
+
+
+def areSame(a:Sequence[Any]|None, b:Sequence[Any]|None, sort:bool=False, sortFunction:Optional[Callable[[Any], Any]]=None) -> bool:
+    """
+    Check if two sequences contain the same elements in the same order.
+    
+    :param Sequence[Any]|None a: The sequence to check
+    :param Sequence[Any]|None b: The sequence to compare against
+    :param Optional[bool] sort: Sort sequences before performing comparisons.
+    :param Optional[Callable[[Any], Any]] sortFunction: Custom function to use when sorting.
+    :returns bool: True if the sequences contain the same elements in the same order, False otherwise.
+    """
+    if a is b:
+        return True
+    elif a is None and b is not None:
+        return False
+    elif a is not None and b is None:
+        return False
+    elif a is not None and b is not None:
+        if len(a) != len(b):
+            return False
+
+        if sort:
+            if isinstance(a, dict) or isinstance(b, dict):
+                sortFunction = sortFunction if sortFunction is not None else lambda e: e[0]
+                a = sorted(cast(dict,a).items(), key=sortFunction)
+                b = sorted(cast(dict,b).items(), key=sortFunction)
+            else:
+                sortFunction = sortFunction if sortFunction is not None else lambda e: e
+                a = sorted(a, key=sortFunction)
+                b = sorted(b, key=sortFunction)
+
+        if isinstance(a, dict) or isinstance(b, dict):
+            for pairs in zip(cast(dict,a).items(), cast(dict,b).items()):
+                if not areSame(pairs[0], pairs[1]):
+                    return False            
+        else:
+            for pairs in zip(a, b):
+                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
+    return True
+
+def hasLength(sequence:Sequence[Any]|None, expected:int|None) -> bool:
+    """
+    Check if a sequence has the expected number of elements.
+    
+    :param Sequence[Any]|None sequence: The sequence 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 sequence is None and (expected is None or expected == 0):
+        return True
+    elif sequence is None and (expected is not None and expected != 0):
+        return False
+    elif sequence is not None and expected is None:
+        return False
+    return sequence is not None and len(sequence) == expected
+
+def isNoneOrEmpty(sequence:Sequence[Any]|None) -> bool:
+    """
+    Check if a sequence is None or empty.
+
+    :param Sequence[Any]|None sequence: The sequence to check
+    :returns bool: True if the sequence is None or empty, False otherwise
+    """
+    if sequence is None:
+        return True
+    return len(sequence) == 0

punit/assertions/exceptions.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: © Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from typing import Any, Callable, Optional, cast, get_args
+
+
+def isNoneOrWhiteSpace(input:str):
+    return input is None or len(input.lstrip()) == 0
+
+
+def isNoneOrEmpty(input:str):
+    return input is None or len(input) == 0
+
+
+class raises[TError:Exception]:
+    
+    __action:Callable
+    __exact:bool
+    __expect:Optional[TError|type]
+
+    def __init__(self, action:Callable, *, exact:bool = False, expect:Optional[TError|type] = None) -> None:
+        self.__action = action
+        self.__exact = exact
+        self.__expect = expect
+
+    def __bool__(self) -> bool:
+        try:
+            self.__action()
+        except BaseException as ex:
+            expected = self.__expect
+            if expected is None and hasattr(self, '__orig_class__') is not None:
+                expected = get_args(getattr(self, '__orig_class__'))[0]
+            if self.__exact:
+                return type(ex) is expected
+            elif expected is not None:
+                return issubclass(type(ex), cast(Any,expected))
+        return False

punit/assertions/strings.py

@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: © Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from typing import Any
+
+def areSame(a:str|None, b:str|None) -> bool:
+    """
+    Check if two strings contain the same characters in the same order.
+
+    Args:
+        a: The first string
+        b: The second string
+        
+    Returns:
+        True if the strings contain the same characters in the same order, False otherwise
+    """
+    if a is None and b is not None:
+        return False
+    elif a is not None and b is None:
+        return False
+    elif a is not None and b is not None:
+        if len(a) != len(b):
+            return False
+        for i in range(len(a)):
+            if a[i] != b[i]:
+                return False
+    return True
+
+def isNoneOrEmpty(string:str|None) -> bool:
+    """
+    Check if a string is None or empty.
+
+    Args:
+        string: The string to check
+        
+    Returns:
+        True if the string is None or empty, False otherwise
+    """
+    if string is None:
+        return True
+    return len(string) == 0
+
+def isNoneOrWhitespace(string:str|None) -> bool:
+    """
+    Check if a string is None or whitespace.
+
+    Args:
+        string: The string to check
+        
+    Returns:
+        True if the string is None or whitespace, False otherwise
+    """
+    if string is None:
+        return True
+    return len(string.strip()) == 0