punit 0.0.27__py3-none-any.whl

punit/TestResult.py

@@ -0,0 +1,180 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+import sys
+from typing import TextIO
+
+class TextIOCapture:
+
+    __quiet:bool
+    output:str = 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:str
+    __exception:Exception
+    __fileName:str
+    __hostName:str
+    __isSuccess:bool
+    __moduleName:str
+    __packageName:str
+    __properties:dict[str, str]
+    __startTime:float
+    __stderrCapture:TextIOCapture
+    __stdoutCapture:TextIOCapture
+    __stopTime:float
+    __testName:str
+
+    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 = {}
+        self.__startTime = None
+        self.__stderrCapture = None
+        self.__stdoutCapture = None
+        self.__stopTime = None
+        self.__testName = None
+
+    @property
+    def className(self) -> str:
+        return self.__className
+    
+    @className.setter
+    def className(self, value:str) -> None:
+        self.__className = value
+
+    @property
+    def exception(self) -> Exception:
+        return self.__exception
+    
+    @exception.setter
+    def exception(self, value:Exception) -> None:
+        self.__exception = value
+
+    @property
+    def fileName(self) -> str:
+        return self.__fileName
+    
+    @fileName.setter
+    def fileName(self, value:str) -> None:
+        self.__fileName = value
+
+    @property
+    def hostName(self) -> str:
+        return self.__hostName
+    
+    @hostName.setter
+    def hostName(self, value:str) -> None:
+        self.__hostName = value
+
+    @property
+    def isSuccess(self) -> bool:
+        return self.__isSuccess
+    
+    @isSuccess.setter
+    def isSuccess(self, value:bool) -> None:
+        self.__isSuccess = value
+
+    @property
+    def moduleName(self) -> str:
+        return self.__moduleName
+    
+    @moduleName.setter
+    def moduleName(self, value:str) -> None:
+        self.__moduleName = value
+
+    @property
+    def packageName(self) -> str:
+        return self.__packageName
+    
+    @packageName.setter
+    def packageName(self, value:str) -> None:
+        self.__packageName = value
+
+    @property
+    def properties(self) -> dict[str, str]:
+        return self.__properties
+    
+    @properties.setter
+    def properties(self, value:dict[str, str]) -> None:
+        self.__properties = value
+
+    @property
+    def startTime(self) -> float:
+        return self.__startTime
+    
+    @startTime.setter
+    def startTime(self, value:float) -> None:
+        self.__startTime = value
+
+    @property
+    def stderr(self) -> str:
+        return None if self.__stderrCapture is None else self.__stderrCapture.output
+
+    @property
+    def stdout(self) -> str:
+        return None if self.__stdoutCapture is None else self.__stdoutCapture.output
+
+    @property
+    def stopTime(self) -> float:
+        return self.__stopTime
+    
+    @stopTime.setter
+    def stopTime(self, value:float) -> None:
+        self.__stopTime = value
+
+    @property
+    def testName(self) -> str:
+        return self.__testName
+    
+    @testName.setter
+    def testName(self, value:str) -> None:
+        self.__testName = value
+
+    @property
+    def took(self) -> float:
+        return self.__stopTime - self.__startTime
+
+    @property
+    def tookPretty(self) -> str:
+        took = self.took
+        if 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) -> tuple[TextIO, TextIO]:
+        self.__stdoutCapture = TextIOCapture(sys.stdout, quiet)
+        self.__stderrCapture = TextIOCapture(sys.stderr, quiet)
+        sys.stdout = self.__stdoutCapture
+        sys.stderr = self.__stderrCapture
+
+    def releaseOutput(self) -> None:
+        sys.stdout = self.__stdoutCapture.target
+        sys.stderr = self.__stderrCapture.target

punit/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+__version__ = '0.0.27'
+
+from .assertions import *
+from .facts import *
+from .theories import *

punit/__main__.py

@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+import asyncio
+from .cli import *
+from .discovery import *
+from .reports import HtmlReportGenerator, JUnitReportGenerator
+from .runner import *
+
+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
+        match cli.reportFormat:
+            case 'html':
+                report = HtmlReportGenerator().generate(results)
+            case 'junit':
+                report = JUnitReportGenerator().generate(results)
+        if cli.outputFilename is None:
+            print(report)
+        else:
+            with open(cli.outputFilename, 'wt') as file:
+                file.write(report)
+            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,7 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+__all__ = [
+    'collections',
+    'exceptions'
+]

punit/assertions/collections.py

@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from typing import Any, Sequence
+
+def areSame(a:Sequence[Any], b:Sequence[Any]) -> bool:
+    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 len(a) != len(b):        
+        return False
+    for i in range(len(a)):
+        if not a[i] == b[i]:
+            return False
+    return True

punit/assertions/exceptions.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from typing import Callable, 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:TError
+
+    def __init__(self, action:Callable, *, exact:bool = False, expect:TError = 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:
+                expected = get_args(self.__orig_class__)[0]
+            if self.__exact:
+                return type(ex) is expected
+            else:
+                return issubclass(type(ex), expected)

punit/cli.py

@@ -0,0 +1,261 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+import os
+import sys
+import typing
+from . import __version__
+
+CommandLineInterface = typing.ForwardRef('CommandLineInterface')
+
+class CommandLineInterface:
+
+    __excludePatterns:list[str]
+    __failfast:bool
+    __filterPattern:str
+    __help:bool
+    __includePatterns:list[str]
+    __no_default_patterns:bool
+    __outputFilename:str
+    __quiet:bool
+    __reportFormat:str
+    __testPackageName:str
+    __verbose:bool
+    __workdir:str
+
+    def __init__(self):
+        self.__aliases = {}
+        self.__excludePatterns = []
+        self.__failfast = False
+        self.__filterPattern = '*'
+        self.__help = False
+        self.__includePatterns = []
+        self.__no_default_patterns = False
+        self.__outputFilename = None
+        self.__quiet = False
+        self.__reportFormat = None
+        self.__testPackageName = 'tests'
+        self.__workdir = os.path.curdir
+        self.__verbose = False
+
+    def __parse(self, argv:list[str]) -> CommandLineInterface:
+        aliasName:str = None
+        extractFilterPattern:bool = False
+        extractExcludePattern:bool = False
+        extractIncludePattern:bool = False
+        extractAliasName:bool = False
+        extractAliasPath:bool = False
+        extractReportFormat:bool = False
+        extractOutputFilename:bool = False
+        for arg in argv:
+            if extractFilterPattern:
+                self.__filterPattern = arg
+                extractFilterPattern = False
+                continue
+            if extractIncludePattern:
+                self.__includePatterns.append(arg)
+                extractIncludePattern = False
+                continue
+            elif extractExcludePattern:
+                self.__excludePatterns.append(arg)
+                extractExcludePattern = False
+                continue
+            elif extractAliasName:
+                aliasName = arg
+                extractAliasName = False
+                extractAliasPath = True
+                continue
+            elif extractAliasPath:
+                extractAliasPath = False
+                self.__aliases[aliasName] = arg
+                continue
+            elif self.__workdir is None:
+                self.__workdir = arg
+                continue
+            elif self.__testPackageName is None:
+                self.__testPackageName = arg
+                continue
+            elif extractReportFormat:
+                extractReportFormat = False
+                self.__reportFormat = arg.lower()
+                match self.__reportFormat:
+                    case 'html' | 'junit':
+                        pass
+                    case _:
+                        print(f'Unsupported value "{arg}" for --report argument, aborting.')
+                        print(f'(valid values are "json" and "junit")')
+                        exit(4)
+                continue
+            elif extractOutputFilename:
+                extractOutputFilename = False
+                self.__outputFilename = arg
+                continue
+            match arg:
+                case '-h' | '--help':
+                    self.__help = True
+                case '-a':
+                    extractAliasName = True
+                case '-t' | '--filter':
+                    extractFilterPattern = True
+                case '-e' | '--exclude':
+                    extractExcludePattern = True
+                case '-f' | '--failfast':
+                    self.__failfast = True
+                case '-p' | '--test-package':
+                    self.__testPackageName = None
+                case '-i' | '--include':
+                    extractIncludePattern = True
+                case '-q' | '--quiet':
+                    self.__quiet = True
+                case '-w' | '--working-directory':
+                    self.__workdir = None
+                case '-v' | '--verbose':
+                    self.__verbose = True
+                case '-n' | '--no-default-patterns':
+                    self.__no_default_patterns = True
+                case '-r' | '--report':
+                    extractReportFormat = True
+                case '-o' | '--output':
+                    extractOutputFilename = True
+                case _:
+                    continue
+        return self
+
+    @property
+    def aliases(self) -> bool:
+        return self.__aliases
+
+    @property
+    def failfast(self) -> bool:
+        return self.__failfast
+
+    @property
+    def filterPattern(self) -> str:
+        return self.__filterPattern
+
+    @property
+    def excludePatterns(self) -> list[str]:
+        return self.__excludePatterns
+
+    @property
+    def help(self) -> bool:
+        return self.__help
+
+    @property
+    def includePatterns(self) -> list[str]:
+        return self.__includePatterns
+
+    @property
+    def outputFilename(self) -> str|None:
+        return self.__outputFilename
+
+    @property
+    def quiet(self) -> bool:
+        return self.__quiet or (self.__reportFormat is not None and self.__outputFilename is None)
+
+    @property
+    def reportFormat(self) -> str|None:
+        return self.__reportFormat
+
+    @property
+    def testPackageName(self) -> str:
+        return self.__testPackageName
+
+    @property
+    def verbose(self) -> bool:
+        return self.__verbose and self.__reportFormat is None 
+
+    @property
+    def workdir(self) -> str:
+        return self.__workdir
+
+    def printHelp(self) -> None:
+        self.printVersion()
+        print(
+"""
+Usage: python3 -m punit [-h|--help]
+                        [-q|--quiet] [-v|--verbose]
+                        [-f|--failfast]
+                        [-p|--test-package NAME]
+                        [-i|--include PATTERN]
+                        [-e|--exclude PATTERN]
+                        [-t|--filter PATTERN]
+                        [-w|--workdir DIRECTORY]
+                        [-n|--no-default-patterns]
+                        [-r|--report {junit|json}]
+                        [-o|--output FILENAME]
+
+Options:
+    -h, --help           Show this help text and exit
+    -q, --quiet          Quiet output
+    -v, --verbose        Verbose output
+    -f, --failfast       Stop on first failure or error
+    -p, --test-package NAME
+        Use NAME as the test package, all tests should
+        be locatable as modules in the named package.
+        Default: 'tests'
+    -i, --include PATTERN
+        Include any tests matching PATTERN
+        Default: '*.py'
+    -e, --exclude PATTERN
+        Exclude any tests matching PATTERN, overriding --include
+        Default: '__*__' (dunder files), '/.*/' (dot-directories)
+    -t, --filter
+        Only execute tests matching PATTERN
+        Default: '*'
+    -w, --working-directory DIRECTORY
+        Working directory (defaults to start directory)
+    -n, --no-default-patterns
+        Do not apply any default include/exclude patterns.
+    -r, --report {html|junit}
+        Generate a report to stdout using either an "html"
+        or "junit" format. When generating a report to stdout
+        all other output is suppressed, unless `--output`
+        is also specified.
+    -o, --output FILENAME
+        If `--report` is used, instead of writing to stdout
+        write to FILENAME. In this case `--report` does not
+        suppress any program output.
+"""
+        )
+        exit(0)
+
+    def printSummary(self) -> None:
+        self.printVersion()
+        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:
+            print('Include Patterns:')
+            for pattern in self.__includePatterns:
+                print(f'\t{pattern}')
+        if len(self.__excludePatterns) > 0:
+            print('Exclude Patterns:')
+            for pattern in self.__excludePatterns:
+                print(f'\t{pattern}')
+        print('Filter Pattern:')
+        print(f'\t{self.__filterPattern}')
+    def printVersion(self) -> None:
+        print(f'pUnit {__version__}')
+
+    def validate(self) -> None:
+        if self.__workdir is None or len(self.__workdir.lstrip()) == 0 or self.__workdir.startswith('-'):
+            print(f'Invalid working directory specified: {self.__workdir}')
+            exit(1)
+        elif not os.path.isdir(self.__workdir):
+            print(f'Working directory does not exist: {self.__workdir}')
+            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 len(self.__includePatterns) == 0:
+                self.__includePatterns.append(f'/{self.testPackageName}/*.py')
+            # always exclude dot-folders (.git, .venv, etc)
+            self.__excludePatterns.append('/.*')
+            # always exclude dunder files
+            self.__excludePatterns.append('/__*__')
+
+    @staticmethod
+    def parse(argv:list[str] = sys.argv) -> CommandLineInterface:
+        result = CommandLineInterface().__parse(argv)
+        result.validate()
+        return result

punit/discovery/TestModuleDiscovery.py

@@ -0,0 +1,104 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+import os
+import re
+
+from ..facts import FactManager
+from ..theories import TheoryManager
+from ..cli import CommandLineInterface
+
+class TestModuleDiscovery:
+
+    __cli:CommandLineInterface
+    __excludePatterns:list[re.Pattern]
+    __filenames:list[str]
+    __filterPattern:re.Pattern
+    __includePatterns:list[re.Pattern]
+    __workdir:str
+
+    def __init__(self, workdir:str, includePatterns:list[str], excludePatterns:list[str], cli:CommandLineInterface):
+        self.__cli = cli
+        self.__excludePatterns = []
+        if excludePatterns is not None:
+            for pattern in excludePatterns:
+                self.__excludePatterns.append(
+                    re.compile(
+                        self.__convertPatternToRegex(pattern),
+                        re.IGNORECASE))
+        self.__filenames = []
+        self.__filterPattern = re.compile(self.__convertPatternToRegex(cli.filterPattern))
+        self.__includePatterns = []
+        if includePatterns is not None:
+            for pattern in includePatterns:
+                self.__includePatterns.append(
+                    re.compile(
+                        self.__convertPatternToRegex(pattern),
+                        re.IGNORECASE))
+        self.__workdir = workdir
+
+    def __convertPatternToRegex(self, pattern:str):
+        result = re.escape(pattern)\
+            .replace('\\\\', '/')\
+            .replace('\\*', r'.+')\
+            .replace('?', '.')
+        return result
+
+    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:
+        for pat in self.__excludePatterns:
+            if len(pat.findall(input)) > 0:
+                return True
+        return False
+
+    def __walkDirectory(self, path:str) -> list[str]:
+        filenames = []
+        if os.path.isdir(path):
+            for dname, dlist, flist in os.walk(path, topdown=True):
+                if self.__cli.verbose:
+                    print(f'.. discovery for: {dname}')
+                dname2 = dname.replace('\\', '/')
+                if self.__testAnyExclude(dname2):
+                    # directory is excluded, prune all children
+                    if self.__cli.verbose:
+                        print(f'Excluded: {dname}')
+                    while len(dlist) > 0:
+                        del dlist[0]
+                    while len(flist) > 0:
+                        del flist[0]
+                # determine if any individual subdirs should be pruned
+                dlnames = dlist.copy()
+                for dlname in dlnames:
+                    dlname2 = dlname.replace('\\', '/')
+                    if self.__testAnyExclude(dlname2):
+                        if self.__cli.verbose:
+                            print(f'Excluded: {dlname}')
+                        dlist.remove(dlname)
+                # determine if any individual files should be pruned
+                for fname in flist:
+                    fname2 = os.path.join(dname, fname).replace('\\', '/')
+                    if self.__testAnyInclude(fname2) and not self.__testAnyExclude(fname2):
+                        if fname.endswith('.py'):
+                            if self.__cli.verbose:
+                                print(f'Included: {fname}')
+                            filenames.append(fname2)
+        return filenames
+
+    @property
+    def filenames(self) -> list[str]:
+        return self.__filenames
+        
+    def discover(self) -> list[str]:
+        FactManager.instance().filterPattern = self.__filterPattern
+        TheoryManager.instance().filterPattern = self.__filterPattern
+        if self.__cli.verbose:
+            print(f'.. starting test discovery')
+        self.__filenames = self.__walkDirectory(self.__workdir)
+        if self.__cli.verbose:
+            print('.. finished test discovery.')
+        return self.__filenames

punit/discovery/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+__all__ = [
+    'TestModuleDiscovery'
+]
+
+from .TestModuleDiscovery import *