orionis 0.404.0__py3-none-any.whl → 0.406.0__py3-none-any.whl

orionis/test/validators/fail_fast.py

@@ -0,0 +1,37 @@
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidFailFast:
+
+    def __call__(self, fail_fast) -> bool:
+        """
+        Validator that ensures the `fail_fast` parameter is a boolean.
+
+        This class is intended to be used as a callable validator to check that the
+        provided `fail_fast` argument is of type `bool`. If the value is not a boolean,
+        an `OrionisTestValueError` is raised with a descriptive error message.
+
+        Parameters
+        ----------
+        fail_fast : Any
+            The value to be validated as a boolean.
+
+        Returns
+        -------
+        bool
+            The validated boolean value of `fail_fast`.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If `fail_fast` is not of type `bool`.
+        """
+
+        if not isinstance(fail_fast, bool):
+            raise OrionisTestValueError(
+                f"Invalid fail_fast: Expected a boolean, got '{fail_fast}' ({type(fail_fast).__name__})."
+            )
+
+        return fail_fast
+
+# Exported singleton instance
+ValidFailFast = __ValidFailFast()

orionis/test/validators/folder_path.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidFolderPath:
+
+    def __call__(self, folder_path: str) -> str:
+        """
+        Validate and clean a folder path string.
+
+        Parameters
+        ----------
+        folder_path : str
+            The folder path to validate.
+
+        Returns
+        -------
+        str
+            The cleaned folder path string.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If the folder_path is not a non-empty string.
+        """
+
+        if not isinstance(folder_path, str) or not folder_path.strip():
+            raise OrionisTestValueError(
+                f"Invalid folder_path: Expected a non-empty string, got '{str(folder_path)}' ({type(folder_path).__name__})."
+            )
+
+        return folder_path.strip()
+
+# Exported singleton instance
+ValidFolderPath = __ValidFolderPath()

orionis/test/validators/module_name.py

@@ -0,0 +1,31 @@
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidModuleName:
+
+    def __call__(self, module_name) -> str:
+        """
+        Validator that ensures the `module_name` parameter is a non-empty string.
+
+        Parameters
+        ----------
+        module_name : Any
+            The value to be validated as a non-empty string.
+
+        Returns
+        -------
+        str
+            The validated and stripped string value of `module_name`.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If `module_name` is not a non-empty string.
+        """
+        if not module_name or not isinstance(module_name, str):
+            raise OrionisTestValueError(
+                f"Invalid module_name: Expected a non-empty string, got '{module_name}' ({type(module_name).__name__})."
+            )
+        return module_name
+
+# Exported singleton instance
+ValidModuleName = __ValidModuleName()

orionis/test/validators/name_pattern.py

@@ -0,0 +1,40 @@
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidNamePattern:
+
+    def __call__(self, test_name_pattern) -> str:
+        """
+        Validator that ensures the `test_name_pattern` parameter is a non-empty string.
+
+        This class is intended to be used as a callable validator to check that the
+        provided `test_name_pattern` argument is a non-empty string. If the value is not a valid
+        string, an `OrionisTestValueError` is raised with a descriptive error message.
+
+        Parameters
+        ----------
+        test_name_pattern : Any
+            The value to be validated as a non-empty string.
+
+        Returns
+        -------
+        str
+            The validated and stripped string value of `test_name_pattern`.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If `test_name_pattern` is not a non-empty string.
+        """
+
+        if test_name_pattern is not None:
+
+            if not isinstance(test_name_pattern, str) or not test_name_pattern.strip():
+                raise OrionisTestValueError(
+                    f"Invalid test_name_pattern: Expected a non-empty string, got '{str(test_name_pattern)}' ({type(test_name_pattern).__name__})."
+                )
+            return test_name_pattern.strip()
+
+        return test_name_pattern
+
+# Exported singleton instance
+ValidNamePattern = __ValidNamePattern()

orionis/test/validators/pattern.py

@@ -0,0 +1,36 @@
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidPattern:
+
+    def __call__(self, pattern) -> str:
+        """
+        Validator that ensures the `pattern` parameter is a non-empty string.
+
+        This class is intended to be used as a callable validator to check that the
+        provided `pattern` argument is a non-empty string. If the value is not a valid
+        string, an `OrionisTestValueError` is raised with a descriptive error message.
+
+        Parameters
+        ----------
+        pattern : Any
+            The value to be validated as a non-empty string.
+
+        Returns
+        -------
+        str
+            The validated and stripped string value of `pattern`.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If `pattern` is not a non-empty string.
+        """
+
+        if not isinstance(pattern, str) or not pattern.strip():
+            raise OrionisTestValueError(
+                f"Invalid pattern: Expected a non-empty string, got '{str(pattern)}' ({type(pattern).__name__})."
+            )
+        return pattern.strip()
+
+# Exported singleton instance
+ValidPattern = __ValidPattern()

orionis/test/validators/persistent.py

@@ -0,0 +1,42 @@
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidPersistent:
+
+    def __call__(self, persistent) -> bool:
+        """
+        Validator that ensures the `persistent` parameter is a boolean.
+
+        This class is intended to be used as a callable validator to check if the
+        provided value for `persistent` is of type `bool`. If the value is not a
+        boolean, an `OrionisTestValueError` is raised.
+
+        Methods
+        -------
+        __call__(persistent) -> bool
+            Validates that `persistent` is a boolean.
+
+        Parameters
+        ----------
+        persistent : Any
+            The value to be validated as a boolean.
+
+        Returns
+        -------
+        bool
+            Returns the value of `persistent` if it is a boolean.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If `persistent` is not a boolean.
+        """
+
+        if not isinstance(persistent, bool):
+            raise OrionisTestValueError(
+                f"Invalid persistent: Expected a boolean, got '{persistent}' ({type(persistent).__name__})."
+            )
+
+        return persistent
+
+# Exported singleton instance
+ValidPersistent = __ValidPersistent()

orionis/test/validators/persistent_driver.py

@@ -0,0 +1,43 @@
+from orionis.foundation.config.testing.enums.drivers import PersistentDrivers
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidPersistentDriver:
+
+    def __call__(self, persistent_driver) -> str:
+        """
+        Validator class for persistent driver types.
+        This class is intended to validate the value of a persistent driver, ensuring
+        that it is a string or PersistentDrivers enum and one of the accepted values.
+        Methods
+        -------
+        __call__(persistent_driver: str | PersistentDrivers) -> str
+            Validates the given persistent driver. Raises an OrionisTestValueError if
+            the input is not a string or enum or not one of the accepted values.
+        Parameters
+        ----------
+        persistent_driver : str | PersistentDrivers
+            The persistent driver to validate. Must be either 'sqlite', 'json', or the corresponding enum.
+        Returns
+        -------
+        str
+            The validated persistent driver as a string.
+        Raises
+        ------
+        OrionisTestValueError
+            If the input is not a string/enum or not one of the accepted values.
+        """
+
+        if not isinstance(persistent_driver, (str, PersistentDrivers)):
+            raise OrionisTestValueError(
+            f"Invalid type for persistent_driver: Expected str or PersistentDrivers, got {type(persistent_driver).__name__}."
+            )
+        if isinstance(persistent_driver, PersistentDrivers):
+            return persistent_driver.value
+        if persistent_driver in [e.value for e in PersistentDrivers]:
+            return persistent_driver
+        raise OrionisTestValueError(
+            f"Invalid persistent_driver: Expected one of {[e.value for e in PersistentDrivers]}, got '{persistent_driver}'."
+        )
+
+# Export the validator instance singleton
+ValidPersistentDriver = __ValidPersistentDriver()

orionis/test/validators/print_result.py

@@ -0,0 +1,37 @@
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidPrintResult:
+
+    def __call__(self, print_result) -> bool:
+        """
+        Validator that ensures the `print_result` parameter is a boolean.
+
+        This class is intended to be used as a callable validator to check that the
+        provided `print_result` argument is of type `bool`. If the validation fails,
+        an `OrionisTestValueError` is raised.
+
+        Parameters
+        ----------
+        print_result : Any
+            The value to be validated as a boolean.
+
+        Returns
+        -------
+        bool
+            Returns the validated boolean value of `print_result`.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If `print_result` is not of type `bool`.
+        """
+
+        if not isinstance(print_result, bool):
+            raise OrionisTestValueError(
+                f"Invalid print_result: Expected a boolean, got '{print_result}' ({type(print_result).__name__})."
+            )
+
+        return print_result
+
+# Exported singleton instance
+ValidPrintResult = __ValidPrintResult()

orionis/test/validators/tags.py

@@ -0,0 +1,37 @@
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidTags:
+
+    def __call__(self, tags):
+        """
+        Validator that ensures the `tags` parameter is a non-empty list of non-empty strings.
+
+        Parameters
+        ----------
+        tags : Any
+            The value to be validated as a list of non-empty strings.
+
+        Returns
+        -------
+        list
+            The validated and stripped list of tags.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If `tags` is not a non-empty list of non-empty strings.
+        """
+
+        if tags is not None:
+
+            if (not isinstance(tags, list) or not tags or not all(isinstance(tag, str) and tag.strip() for tag in tags)):
+                raise OrionisTestValueError(
+                    f"Invalid tags: Expected a non-empty list of non-empty strings, got '{tags}' ({type(tags).__name__})."
+                )
+
+            return [str(tag).strip() for tag in tags]
+
+        return None
+
+# Exported singleton instance
+ValidTags = __ValidTags()

orionis/test/validators/throw_exception.py

@@ -0,0 +1,39 @@
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidThrowException:
+
+    def __call__(self, throw_exception) -> bool:
+        """
+        __ValidThrowException is a validator class that ensures the `throw_exception` parameter is a boolean.
+
+        Methods
+        -------
+        __call__(throw_exception) -> bool
+            Validates that the input `throw_exception` is of type `bool`. If not, raises an OrionisTestValueError
+            with a descriptive message. Returns the validated boolean value.
+
+        Parameters
+        ----------
+        throw_exception : Any
+            The value to be validated as a boolean.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If `throw_exception` is not a boolean.
+
+        Returns
+        -------
+        bool
+            The validated boolean value of `throw_exception`.
+        """
+
+        if not isinstance(throw_exception, bool):
+            raise OrionisTestValueError(
+                f"Invalid throw_exception: Expected a boolean, got '{throw_exception}' ({type(throw_exception).__name__})."
+            )
+
+        return throw_exception
+
+# Exported singleton instance
+ValidThrowException = __ValidThrowException()

orionis/test/validators/verbosity.py

@@ -0,0 +1,37 @@
+from orionis.foundation.config.testing.enums.verbosity import VerbosityMode
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidVerbosity:
+    """
+    Validator that ensures the verbosity level is a non-negative integer or a valid VerbosityMode.
+    """
+
+    def __call__(self, verbosity) -> int:
+        """
+        Ensures that the provided verbosity is a non-negative integer or a valid VerbosityMode.
+
+        Parameters
+        ----------
+        verbosity : int or VerbosityMode
+            The verbosity level to validate.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If the verbosity is not a non-negative integer or a valid VerbosityMode.
+        """
+        if isinstance(verbosity, VerbosityMode):
+            return verbosity.value
+        if isinstance(verbosity, int) and verbosity >= 0:
+            if verbosity in [mode.value for mode in VerbosityMode]:
+                return verbosity
+            else:
+                raise OrionisTestValueError(
+                    f"Invalid verbosity level: {verbosity} is not a valid VerbosityMode value."
+                )
+        raise OrionisTestValueError(
+            f"Invalid verbosity level: Expected a non-negative integer or VerbosityMode, got '{verbosity}' ({type(verbosity).__name__})."
+        )
+
+# Exported singleton instance
+ValidVerbosity = __ValidVerbosity()

orionis/test/validators/web_report.py

@@ -0,0 +1,35 @@
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidWebReport:
+
+    def __call__(self, web_report) -> bool:
+        """
+        Validator class to check if the input is a boolean value.
+        This class is intended to be used as a callable to validate whether the provided
+        `web_report` argument is of type `bool`. If the input is not a boolean, an
+        `OrionisTestValueError` is raised with a descriptive error message.
+
+        Parameters
+        ----------
+        None
+
+        Methods
+        -------
+        __call__(web_report)
+            Validates that `web_report` is a boolean value.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If `web_report` is not of type `bool`.
+        """
+
+        if not isinstance(web_report, bool):
+            raise OrionisTestValueError(
+                f"Invalid web_report: Expected a boolean, got '{web_report}' ({type(web_report).__name__})."
+            )
+
+        return web_report
+
+# Exported singleton instance
+ValidWebReport = __ValidWebReport()

orionis/test/validators/workers.py

@@ -0,0 +1,31 @@
+from orionis.support.facades.workers import Workers
+from orionis.test.exceptions import OrionisTestValueError
+
+class __ValidWorkers:
+    """
+    Validator that ensures max_workers is a positive integer within allowed range.
+    """
+
+    def __call__(self, max_workers: int) -> int:
+        """
+        Ensures that the provided max_workers is a positive integer within allowed range.
+
+        Parameters
+        ----------
+        max_workers : int
+            The max_workers value to validate.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If max_workers is not a positive integer within allowed range.
+        """
+        max_allowed = Workers.calculate()
+        if not isinstance(max_workers, int) or max_workers < 1 or max_workers > max_allowed:
+            raise OrionisTestValueError(
+                f"Invalid max_workers: Expected a positive integer between 1 and {max_allowed}, got '{max_workers}' ({type(max_workers).__name__})."
+            )
+        return max_workers
+
+# Exported singleton instance
+ValidWorkers = __ValidWorkers()

orionis/test/view/render.py

@@ -1,7 +1,6 @@
 import json
 import os
 from pathlib import Path
-from orionis.services.environment.env import Env
 from orionis.test.contracts.render import ITestingResultRender
 from orionis.test.records.logs import TestLogs
 
@@ -10,56 +9,44 @@ class TestingResultRender(ITestingResultRender):
     def __init__(
         self,
         result,
-        storage_path:str = None,
-        persist=False
+        storage_path: str,
+        persist: bool = False
     ) -> None:
         """
-        Initialize the TestingResultRender object.
+        Initialize a TestingResultRender instance for rendering test results.
+
+        This constructor sets up the renderer with the provided test result data,
+        determines the storage location for the generated report, and configures
+        whether persistent storage (e.g., SQLite) should be used for storing and
+        retrieving test reports.
 
         Parameters
         ----------
         result : Any
-            The test result data to be processed or stored.
-        storage_path : str, optional
-            Custom path to store the test report. If not provided, uses the environment variable
-            'TEST_REPORT_PATH' or defaults to a local storage path.
+            The test result data to be rendered and included in the report.
+        storage_path : str
+            The directory path where the HTML report will be saved. If the directory
+            does not exist, it will be created automatically.
         persist : bool, optional
-            Whether to persist the report. Defaults to False.
+            If True, enables persistent storage for test reports (default is False).
 
-        Notes
-        -----
-        - Determines the file path for the test report based on the provided storage_path, environment variable,
-          or a default location.
-        - Ensures the parent directory for the report exists.
-        - Stores the resolved report path in the environment variable 'TEST_REPORT_PATH'.
+        Returns
+        -------
+        None
+            This constructor does not return a value. It initializes internal state
+            and prepares the report path for future rendering.
         """
-
-        # Initialize instance variables
-        self.__filename = 'test-results.html'
+        self.__filename = 'orionis-test-results.html'
         self.__result = result
         self.__persist = persist
+        self.__storage_path = storage_path
 
-        # Determine file path
-        db_path = None
-        if storage_path:
-            db_path = Path(storage_path).expanduser().resolve()
-            if db_path.is_dir():
-                db_path = db_path / self.__filename
-        else:
-            env_path = Env.get("TEST_REPORT_PATH", None)
-            if env_path:
-                db_path = Path(env_path).expanduser().resolve()
-                if db_path.is_dir():
-                    db_path = db_path / self.__filename
-            else:
-                db_path = Path.cwd() / 'storage/framework/testing' / self.__filename
-
-        # Ensure parent directory exists
-        db_path.parent.mkdir(parents=True, exist_ok=True)
+        # Ensure storage_path is a Path object and create the directory if it doesn't exist
+        storage_dir = Path(storage_path)
+        storage_dir.mkdir(parents=True, exist_ok=True)
 
-        # Store path in environment
-        Env.set("TEST_REPORT_PATH", str(db_path), 'path')
-        self.__report_path = db_path
+        # Set the absolute path for the report file
+        self.__report_path = (storage_dir / self.__filename).resolve()
 
     def render(
         self
@@ -88,18 +75,26 @@ class TestingResultRender(ITestingResultRender):
 
         # Determine the source of test results based on persistence mode
         if self.__persist:
+
             # If persistence is enabled, fetch the last 10 reports from SQLite
-            logs = TestLogs()
+            logs = TestLogs(self.__storage_path)
             reports = logs.get(last=10)
+
             # Parse each report's JSON data into a list
             results_list = [json.loads(report[1]) for report in reports]
+
         else:
+
             # If not persistent, use only the current in-memory result
             results_list = [self.__result]
 
         # Set placeholder values for the template
-        persistence_mode = 'SQLite' if self.__persist else 'Static'
-        test_results_json = json.dumps(results_list, ensure_ascii=False, indent=None)
+        persistence_mode = 'Database' if self.__persist else 'Memory'
+        test_results_json = json.dumps(
+            results_list,
+            ensure_ascii=False,
+            indent=None
+        )
 
         # Locate the HTML template file
         template_path = Path(__file__).parent / 'report.stub'
@@ -109,23 +104,22 @@ class TestingResultRender(ITestingResultRender):
             template_content = template_file.read()
 
         # Replace placeholders with actual values
-        rendered_content = template_content.replace(
-            '{{orionis-testing-result}}',
-            test_results_json
-        ).replace(
-            '{{orionis-testing-persistent}}',
-            persistence_mode
-        )
+        rendered_content = template_content.replace('{{orionis-testing-result}}', test_results_json)\
+                                           .replace('{{orionis-testing-persistent}}', persistence_mode)
 
         # Write the rendered HTML report to the specified path
         with open(self.__report_path, 'w', encoding='utf-8') as report_file:
             report_file.write(rendered_content)
 
         # Open the generated report in the default web browser if running on Windows or macOS.
-        # This provides immediate feedback to the user after report generation.
-        if os.name == 'nt' or os.name == 'posix' and sys.platform == 'darwin':
-            import webbrowser
-            webbrowser.open(self.__report_path.as_uri())
+        try:
+
+            # Check the operating system and open the report in a web browser if applicable
+            if ((os.name == 'nt') or (os.name == 'posix' and sys.platform == 'darwin')):
+                import webbrowser
+                webbrowser.open(self.__report_path.as_uri())
+
+        finally:
 
-        # Return the absolute path to the generated report
-        return str(self.__report_path)
+            # Return the absolute path to the generated report
+            return str(self.__report_path)

{orionis-0.404.0.dist-info → orionis-0.406.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.404.0
+Version: 0.406.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro