orionis 0.372.0__py3-none-any.whl → 0.374.0__py3-none-any.whl

orionis/test/cases/test_case.py

@@ -1,42 +0,0 @@
-import unittest
-from orionis.test.output.dumper import TestDumper
-
-class TestCase(unittest.IsolatedAsyncioTestCase, TestDumper):
-    """
-    Base test case for async unit tests.
-    """
-
-    async def asyncSetUp(self):
-        """
-        Asynchronous setup method called before each test.
-
-        This method first calls the parent class's asyncSetUp method to ensure any inherited setup logic is executed.
-        Then, it calls the onAsyncSetup method, which can be used to perform additional asynchronous setup specific to this test case.
-
-        Override this method to customize asynchronous setup behavior for your tests.
-        """
-        await super().asyncSetUp()
-        await self.onAsyncSetup()
-
-    async def asyncTearDown(self):
-        """
-        Asynchronous teardown method called after each test.
-
-        This method performs any necessary asynchronous cleanup by first invoking
-        the custom `onAsyncTeardown` coroutine, followed by the superclass's
-        `asyncTearDown` method to ensure proper teardown in the test lifecycle.
-        """
-        await self.onAsyncTeardown()
-        await super().asyncTearDown()
-
-    async def onAsyncSetup(self):
-        """
-        Hook for subclasses to add async setup logic.
-        """
-        pass
-
-    async def onAsyncTeardown(self):
-        """
-        Hook for subclasses to add async teardown logic.
-        """
-        pass

orionis/test/cases/test_sync.py

@@ -1,33 +0,0 @@
-import unittest
-from orionis.test.output.dumper import TestDumper
-
-class SyncTestCase(unittest.TestCase, TestDumper):
-    """
-    Base test case for sync unit tests.
-    """
-
-    def setUp(self):
-        """
-        Synchronous setup method called before each test.
-        """
-        super().setUp()
-        self.onSetup()
-
-    def tearDown(self):
-        """
-        Synchronous teardown method called after each test.
-        """
-        self.onTeardown()
-        super().tearDown()
-
-    def onSetup(self):
-        """
-        Hook for subclasses to add setup logic.
-        """
-        pass
-
-    def onTeardown(self):
-        """
-        Hook for subclasses to add teardown logic.
-        """
-        pass

orionis/test/contracts/history.py

@@ -1,54 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Tuple
-
-class ITestHistory(ABC):
-
-    @abstractmethod
-    def create(self, report: Dict) -> bool:
-        """
-        Create a new test report in the history database.
-
-        Parameters
-        ----------
-        report : Dict
-            A dictionary containing the test report data.
-
-        Returns
-        -------
-        bool
-            True if the report was successfully created, False otherwise.
-        """
-        pass
-
-    def reset(self) -> bool:
-        """
-        Reset the history database by dropping the existing table.
-
-        Returns
-        -------
-        bool
-            True if the database was successfully reset, False otherwise.
-        """
-        pass
-
-    def get(
-        self,
-        first: Optional[int] = None,
-        last: Optional[int] = None
-    ) -> List[Tuple]:
-        """
-        Retrieve test reports from the history database.
-
-        Parameters
-        ----------
-        first : Optional[int], default=None
-            The number of earliest reports to retrieve, ordered ascending by ID.
-        last : Optional[int], default=None
-            The number of latest reports to retrieve, ordered descending by ID.
-
-        Returns
-        -------
-        List[Tuple]
-            A list of tuples representing the retrieved reports.
-        """
-        pass

orionis/test/test_suite.py

@@ -1,142 +0,0 @@
-import re
-from os import walk
-from orionis.foundation.config.testing.entities.testing import Testing as Configuration
-from orionis.test.exceptions import OrionisTestConfigException
-from orionis.test.core.unit_test import UnitTest
-
-class TestSuite:
-    """
-    TestSuite manages and executes a suite of unit tests based on a configurable set of parameters.
-
-    Parameters
-    ----------
-    config : Configuration, optional
-        Configuration object specifying parameters for test suite execution. If not provided, a new Configuration instance is created.
-
-    Attributes
-    ----------
-    _config : Configuration
-        The configuration object controlling test suite behavior, such as verbosity, execution mode, worker count, and test discovery patterns.
-
-    Methods
-    -------
-    __init__(config=None)
-        Initializes the TestSuite with the provided configuration or a default one.
-    run()
-        Executes the test suite according to the configuration. Discovers test folders matching the specified pattern, adds discovered tests to the suite, and runs them.
-    getResult()
-        Returns the results of the executed test suite.
-    """
-
-    def __init__(self, config:Configuration = None, **kwargs):
-        """
-        Initializes the TestSuite with the provided configuration.
-
-        Parameters
-        ----------
-        config : Configuration, optional
-            Configuration object specifying parameters for test suite execution. If not provided, a new Configuration instance is created.
-        """
-
-        # Check if config is None and kwargs are provided
-        if config is None:
-
-            try:
-
-                # Attempt to create a Configuration instance with provided keyword arguments
-                config = Configuration(**kwargs)
-
-            except TypeError:
-
-                # If a TypeError occurs, it indicates that the provided arguments do not match the Configuration class
-                required_fields = []
-                for field in Configuration().getFields():
-                    required_fields.append(f"{field.get('name')} = (Type: {field.get('type')}, Default: {field.get('default')})")
-
-                # Raise an exception with a detailed message about the required fields
-                raise OrionisTestConfigException(f"The provided configuration is not valid. Please ensure it is an instance of the Configuration class or provide valid keyword arguments. \n{str("\n").join(required_fields)}]")
-
-        # Assign the configuration to the instance variable
-        self.__config = config or Configuration()
-
-    def run(self) -> 'UnitTest':
-        """
-        Runs the test suite based on the provided configuration.
-
-        Initializes a UnitTest suite, configures it with parameters from the Configuration object,
-        discovers test folders matching the specified pattern, adds the discovered tests to the suite,
-        executes the test suite, and returns the results.
-
-        Returns
-        -------
-        UnitTest
-            The result of the executed test suite.
-
-        Raises
-        ------
-        OrionisTestConfigException
-            If the provided configuration is not an instance of Configuration.
-        """
-
-        # Check if the config is provided
-        config = self.__config
-
-        # Check if the config is an instance of Configuration
-        if not isinstance(config, Configuration):
-            raise OrionisTestConfigException("The config parameter must be an instance of the Configuration class.")
-
-        # Initialize the test suite
-        tests = UnitTest()
-
-        # Assign config values to the test suite
-        tests.configure(
-            verbosity=config.verbosity,
-            execution_mode=config.execution_mode,
-            max_workers=config.max_workers,
-            fail_fast=config.fail_fast,
-            print_result=config.print_result,
-            throw_exception=config.throw_exception,
-            persistent=config.persistent,
-            persistent_driver=config.persistent_driver,
-            web_report=config.web_report
-        )
-
-        # Extract configuration values
-        base_path = config.base_path
-        folder_path = config.folder_path
-        pattern = config.pattern
-
-        # Helper function to list folders matching the pattern
-        def list_matching_folders(custom_path: str, pattern: str):
-            matched_folders = []
-            for root, _, files in walk(custom_path):
-                for file in files:
-                    if re.fullmatch(pattern.replace('*', '.*').replace('?', '.'), file):
-                        relative_path = root.replace(base_path, '').replace('\\', '/').lstrip('/')
-                        if relative_path not in matched_folders:
-                            matched_folders.append(relative_path)
-            return matched_folders
-
-        # Discover folders
-        discovered_folders = []
-        if folder_path == '*':
-            discovered_folders.extend(list_matching_folders(base_path, pattern))
-        elif isinstance(folder_path, list):
-            for custom_path in folder_path:
-                discovered_folders.extend(list_matching_folders(f"{base_path}/{custom_path}", pattern))
-        else:
-            discovered_folders.extend(list_matching_folders(folder_path, pattern))
-
-        # Add discovered folders to the test suite
-        for folder in discovered_folders:
-            tests.discoverTestsInFolder(
-                folder_path=folder,
-                base_path=base_path,
-                pattern=pattern,
-                test_name_pattern=config.test_name_pattern if config.test_name_pattern else None,
-                tags=config.tags if config.tags else None
-            )
-
-        # Run the test suite and return the UnitTest instance
-        tests.run()
-        return tests

orionis/unittesting.py

@@ -1,64 +0,0 @@
-# Import custom test case classes from the orionis.test.cases module
-from orionis.test.cases.test_case import TestCase
-from orionis.test.cases.test_sync import SyncTestCase
-from orionis.test.cases.test_async import AsyncTestCase
-
-# Import the custom TestHistory class for logging test results
-from orionis.test.logs.history import TestHistory
-
-# Import the custom TestResult entity
-from orionis.test.entities.test_result import TestResult
-
-# Import enums for execution mode and test status
-from orionis.test.enums.execution_mode import ExecutionMode
-from orionis.test.enums.status import TestStatus
-
-# Import custom exception for test failures
-from orionis.test.exceptions.failure import OrionisTestFailureException
-from orionis.test.exceptions.config import OrionisTestConfigException
-from orionis.test.exceptions.persistence import OrionisTestPersistenceError
-from orionis.test.exceptions.runtime import OrionisTestRuntimeError
-from orionis.test.exceptions.value import OrionisTestValueError
-
-# Import configuration and suite classes for organizing tests
-from orionis.test.test_suite import Configuration, TestSuite
-from orionis.test.core.unit_test import UnitTest
-
-# Import standard unittest components for compatibility
-from unittest import (
-    TestLoader,
-    TestSuite as StandardTestSuite,
-    TestResult as StandardTestResult
-)
-
-# Import mock classes for creating test doubles
-from unittest.mock import (
-    Mock,
-    MagicMock,
-    patch
-)
-
-# Define the public API of this module
-__all__ = [
-    "TestCase",
-    "SyncTestCase",
-    "AsyncTestCase",
-    "TestResult",
-    "ExecutionMode",
-    "TestStatus",
-    "OrionisTestFailureException",
-    "OrionisTestConfigException",
-    "OrionisTestPersistenceError",
-    "OrionisTestRuntimeError",
-    "OrionisTestValueError",
-    "Configuration",
-    "TestSuite",
-    "UnitTest",
-    "TestLoader",
-    "StandardTestSuite",
-    "StandardTestResult",
-    "Mock",
-    "MagicMock",
-    "TestHistory",
-    "patch",
-]