orionis 0.281.0__tar.gz → 0.283.0__tar.gz

orionis-0.283.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include orionis *.py *.html

{orionis-0.281.0/orionis.egg-info → orionis-0.283.0}/PKG-INFO

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

orionis-0.283.0/orionis/application.py

@@ -0,0 +1,10 @@
+from orionis.foundation.config.startup import Configuration
+from orionis.patterns.singleton.meta_class import Singleton
+
+class Orionis(metaclass=Singleton):
+
+    def __init__(
+        self,
+        config: Configuration = None
+    ):
+        self.__config = config or Configuration()

{orionis-0.281.0 → orionis-0.283.0}/orionis/foundation/config/testing/entities/testing.py

@@ -127,6 +127,15 @@ class Testing:
         }
     )
 
+    persistent: bool = field(
+        default=False,
+        metadata={
+            "description": "Whether to keep the test results persistent. Default is False.",
+            "required": True,
+            "default": False
+        }
+    )
+
     def __post_init__(self):
         """
         Post-initialization validation for the testing configuration entity.

{orionis-0.281.0 → orionis-0.283.0}/orionis/metadata/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.281.0"
+VERSION = "0.283.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

{orionis-0.281.0 → orionis-0.283.0}/orionis/services/environment/dot_env.py

@@ -39,7 +39,7 @@ class DotEnv(metaclass=Singleton):
 
             load_dotenv(self._resolved_path)
 
-    def get(self, key: str, default: Optional[Any] = None) -> Any:
+    def get(self, key: str, default: Optional[Any] = None, is_path:bool=False) -> Any:
         """
         Retrieve the value of an environment variable by key.
 
@@ -54,6 +54,8 @@ class DotEnv(metaclass=Singleton):
             key (str): The name of the environment variable to retrieve.
             default (Optional[Any], optional): The value to return if the key is not found.
                 Defaults to None.
+            is_path (bool, optional): If True, the value is treated as a file path and backslashes are replaced with forward slashes.
+                This is useful for Windows paths. Defaults to False.
 
         Returns:
             Any: The parsed value of the environment variable, or the default if not found.
@@ -62,9 +64,9 @@ class DotEnv(metaclass=Singleton):
             value = dotenv_values(self._resolved_path).get(key)
             if value is None:
                 value = os.getenv(key)
-            return self.__parseValue(value) if value is not None else default
+            return self.__parseValue(value, is_path) if value is not None else default
 
-    def set(self, key: str, value: Union[str, int, float, bool, list, dict]) -> bool:
+    def set(self, key: str, value: Union[str, int, float, bool, list, dict], is_path:bool=False) -> bool:
         """
         Sets an environment variable with the specified key and value.
 
@@ -73,12 +75,15 @@ class DotEnv(metaclass=Singleton):
         Args:
             key (str): The name of the environment variable to set.
             value (Union[str, int, float, bool, list, dict]): The value to assign to the environment variable. Supported types include string, integer, float, boolean, list, and dictionary.
+            is_path (bool, optional): If True, the value is treated as a file path and backslashes are replaced with forward slashes.
+            This is useful for Windows paths. Defaults to False.
 
         Returns:
             bool: True if the environment variable was successfully set.
         """
+
         with self._lock:
-            serialized_value = self.__serializeValue(value)
+            serialized_value = self.__serializeValue(value, is_path)
             set_key(str(self._resolved_path), key, serialized_value)
             os.environ[key] = str(value)
             return True
@@ -133,7 +138,7 @@ class DotEnv(metaclass=Singleton):
         with self._lock:
             return base64.b64encode(json.dumps(self.all()).encode()).decode()
 
-    def __parseValue(self, value: Any) -> Any:
+    def __parseValue(self, value: Any, is_path:bool=False) -> Any:
         """
         Parses and converts the input value to an appropriate Python data type.
 
@@ -151,38 +156,51 @@ class DotEnv(metaclass=Singleton):
         """
         if value is None:
             return None
+
         if isinstance(value, (bool, int, float)):
             return value
+
         value_str = str(value).strip()
         if not value_str or value_str.lower() in {'none', 'null', 'nan'}:
             return None
+
         if value_str.lower() == 'true':
             return True
+
         if value_str.lower() == 'false':
             return False
+
+        if is_path:
+            return value_str.replace("\\", "/")
+
         try:
             if value_str.isdigit() or (value_str.startswith('-') and value_str[1:].isdigit()):
                 return int(value_str)
         except Exception:
             pass
+
         try:
             float_val = float(value_str)
             if '.' in value_str or 'e' in value_str.lower():
                 return float_val
         except Exception:
             pass
+
         try:
             return ast.literal_eval(value_str)
         except Exception:
             pass
+
         return value_str
 
-    def __serializeValue(self, value: Any) -> str:
+    def __serializeValue(self, value: Any, is_path:bool=False) -> str:
         """
         Serializes a given value to a string suitable for storage in a .env file.
 
         Parameters:
             value (Any): The value to serialize. Supported types are None, str, bool, int, float, list, and dict.
+            is_path (bool): If True, the value is treated as a file path and backslashes are replaced with forward slashes.
+            This is useful for Windows paths.
 
         Returns:
             str: The serialized string representation of the value.
@@ -191,27 +209,39 @@ class DotEnv(metaclass=Singleton):
             ValueError: If a float value is in scientific notation.
             TypeError: If the value's type is not serializable for .env files.
         """
+        if is_path:
+            return str(value).replace("\\", "/")
+
         if value is None:
             return "None"
+
         if isinstance(value, str):
             return value
+
         if isinstance(value, bool):
             return str(value).lower()
+
         if isinstance(value, int):
             return str(value)
+
         if isinstance(value, float):
             value = str(value)
             if 'e' in value or 'E' in value:
                 raise ValueError('scientific notation is not supported, use a string instead')
             return value
+
         if isinstance(value, (list, dict)):
             return repr(value)
+
         if hasattr(value, '__dict__'):
             raise TypeError(f"Type {type(value).__name__} is not serializable for .env")
+
         if not isinstance(value, (list, dict, bool, int, float, str)):
             raise TypeError(f"Type {type(value).__name__} is not serializable for .env")
+
         if isinstance(value, (list, dict, bool, int, float, str)):
             if type(value).__module__ != "builtins" and not isinstance(value, str):
                 raise TypeError(f"Type {type(value).__name__} is not serializable for .env")
             return repr(value) if not isinstance(value, str) else value
+
         raise TypeError(f"Type {type(value).__name__} is not serializable for .env")

{orionis-0.281.0 → orionis-0.283.0}/orionis/services/environment/env.py

@@ -24,18 +24,18 @@ class Env(IEnv):
         return cls._dotenv_instance
 
     @staticmethod
-    def get(key: str, default: Any = None) -> Any:
+    def get(key: str, default: Any = None, is_path: bool = False) -> Any:
         """
         Retrieve the value of an environment variable by key.
         """
-        return Env._dotenv().get(key, default)
+        return Env._dotenv().get(key, default, is_path)
 
     @staticmethod
-    def set(key: str, value: str) -> bool:
+    def set(key: str, value: str, is_path: bool = False) -> bool:
         """
         Sets the value of an environment variable.
         """
-        return Env._dotenv().set(key, value)
+        return Env._dotenv().set(key, value, is_path)
 
     @staticmethod
     def unset(key: str) -> bool:

{orionis-0.281.0 → orionis-0.283.0}/orionis/test/entities/test_result.py

@@ -73,3 +73,10 @@ class TestResult:
             "description": "Path to the file containing the test, if applicable."
         }
     )
+
+    doc_string: Optional[str] = field(
+        default=None,
+        metadata={
+            "description": "Docstring of the test, if applicable."
+        }
+    )

orionis-0.283.0/orionis/test/logs/contracts/history.py

@@ -0,0 +1,81 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Tuple
+
+class ITestHistory(ABC):
+
+    @abstractmethod
+    def createTableIfNotExists(self) -> None:
+        """
+        Create the 'reportes' table if it does not already exist.
+
+        The table includes fields for the full JSON report and individual
+        statistics for querying and filtering.
+
+        Raises
+        ------
+        RuntimeError
+            If table creation fails due to a database error.
+        """
+        pass
+
+    @abstractmethod
+    def insertReport(self, report: Dict) -> None:
+        """
+        Insert a test report into the database.
+
+        Parameters
+        ----------
+        report : dict
+            Dictionary containing test statistics and metadata.
+
+            Required keys:
+                - total_tests : int
+                - passed : int
+                - failed : int
+                - errors : int
+                - skipped : int
+                - total_time : float
+                - success_rate : float
+                - timestamp : str (ISO format)
+
+        Raises
+        ------
+        ValueError
+            If required keys are missing from the report.
+        RuntimeError
+            If insertion into the database fails.
+        """
+        pass
+
+    def getReports(self) -> List[Tuple]:
+        """
+        Retrieve all test reports from the database.
+
+        Returns
+        -------
+        List[Tuple]
+            A list of tuples representing each row in the `reportes` table.
+
+        Raises
+        ------
+        RuntimeError
+            If retrieval fails due to a database error.
+        """
+        pass
+
+    def resetDatabase(self) -> None:
+        """
+        Drop the `reportes` table, effectively clearing the report history.
+
+        Raises
+        ------
+        RuntimeError
+            If table deletion fails.
+        """
+        pass
+
+    def close(self) -> None:
+        """
+        Close the SQLite database connection gracefully.
+        """
+        pass

orionis-0.283.0/orionis/test/logs/history.py

@@ -0,0 +1,251 @@
+import json
+import sqlite3
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional
+from contextlib import closing
+from orionis.services.environment.env import Env
+from orionis.test.logs.contracts.history import ITestHistory
+
+class TestHistory(ITestHistory):
+    """
+    A utility class for managing test execution reports using a local SQLite database.
+
+    Attributes
+    ----------
+    TABLE_NAME : str
+        The name of the database table where reports are stored.
+    DB_NAME : str
+        The filename of the SQLite database.
+    FIELDS : List[str]
+        List of expected keys in the report dictionary.
+    _conn : sqlite3.Connection or None
+        SQLite database connection instance.
+    """
+
+    TABLE_NAME = "reportes"
+    DB_NAME = "tests.sqlite"
+    FIELDS = [
+        "json", "total_tests", "passed", "failed", "errors",
+        "skipped", "total_time", "success_rate", "timestamp"
+    ]
+
+    def __init__(self, test_db_path: Optional[str] = None) -> None:
+        """
+        Initializes the class instance, setting up the path to the test database.
+        Parameters:
+            test_db_path (Optional[str]): Optional path to the test database file or directory. If a directory is provided, the database file name is appended. If not provided, the method checks the 'TEST_DB_PATH' environment variable, or defaults to a database file in the current file's directory.
+        Behavior:
+            - Resolves the database path to an absolute path.
+            - Ensures the parent directory for the database exists.
+            - Stores the resolved database path in the 'TEST_DB_PATH' environment variable.
+            - Prepares the instance for database connection initialization.
+        """
+
+        if test_db_path:
+
+            # Resolve the provided test_db_path to an absolute path
+            db_path = Path(test_db_path).resolve()
+
+            # If the provided path is a directory, append the database name
+            if db_path.is_dir():
+                db_path = db_path / self.DB_NAME
+
+        else:
+
+            # Check if the TEST_DB_PATH environment variable is set
+            env_path = Env.get(
+                key="TEST_DB_PATH",
+                default=None,
+                is_path=True
+            )
+
+            # If the environment variable is set, resolve it to an absolute path
+            if env_path:
+                db_path = Path(env_path).resolve()
+                if db_path.is_dir():
+                    db_path = db_path / self.DB_NAME
+            else:
+                db_path = Path(__file__).parent / self.DB_NAME
+
+        # Ensure directory exists
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Store the absolute string path in the environment
+        Env.set(
+            key="TEST_DB_PATH",
+            value=str(db_path),
+            is_path=True
+        )
+
+        # Initialize the database connection.
+        self._conn: Optional[sqlite3.Connection] = None
+
+    def __connect(self) -> None:
+        """
+        Establishes a connection to the SQLite database using the path specified in the
+        'TEST_DB_PATH' environment variable. If the environment variable is not set,
+        raises a ConnectionError. If a connection error occurs during the attempt to
+        connect, raises a ConnectionError with the error details.
+        Raises:
+            ConnectionError: If the database path is not set or if a connection error occurs.
+        """
+
+        if self._conn is None:
+
+            # Check if the TEST_DB_PATH environment variable is set
+            db_path = Env.get(
+                key="TEST_DB_PATH",
+                default=None,
+                is_path=True
+            )
+
+            # If not set, raise an error
+            if not db_path:
+                raise ConnectionError("Database path is not set in environment variables.")
+
+            # Try to connect to the SQLite database
+            try:
+                self._conn = sqlite3.connect(db_path)
+            except sqlite3.Error as e:
+                raise ConnectionError(f"Database connection error: {e}")
+
+    def createTableIfNotExists(self) -> None:
+        """
+        Creates the history table in the database if it does not already exist.
+        This method establishes a connection to the database and attempts to create a table
+        with the schema defined by `self.TABLE_NAME`. The table includes columns for test
+        results and metadata such as total tests, passed, failed, errors, skipped, total time,
+        success rate, and timestamp. If the table already exists, no changes are made.
+        Raises a RuntimeError if the table creation fails due to a database error.
+        """
+
+        self.__connect()
+        try:
+            with closing(self._conn.cursor()) as cursor:
+                cursor.execute(f'''
+                    CREATE TABLE IF NOT EXISTS {self.TABLE_NAME} (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        json TEXT NOT NULL,
+                        total_tests INTEGER,
+                        passed INTEGER,
+                        failed INTEGER,
+                        errors INTEGER,
+                        skipped INTEGER,
+                        total_time REAL,
+                        success_rate REAL,
+                        timestamp TEXT
+                    )
+                ''')
+            self._conn.commit()
+        except sqlite3.Error as e:
+            raise RuntimeError(f"Failed to create table: {e}")
+
+    def insertReport(self, report: Dict) -> None:
+        """
+        Inserts a test report into the database.
+        Args:
+            report (Dict): A dictionary containing the report data. Must include the following keys:
+                - total_tests
+                - passed
+                - failed
+                - errors
+                - skipped
+                - total_time
+                - success_rate
+                - timestamp
+        Raises:
+            ValueError: If any required report fields are missing.
+            RuntimeError: If there is an error inserting the report into the database.
+        """
+
+        self.__connect()
+        missing = [key for key in self.FIELDS if key != "json" and key not in report]
+        if missing:
+            raise ValueError(f"Missing report fields: {missing}")
+
+        try:
+            with closing(self._conn.cursor()) as cursor:
+                cursor.execute(f'''
+                    INSERT INTO {self.TABLE_NAME} (
+                        json, total_tests, passed, failed, errors,
+                        skipped, total_time, success_rate, timestamp
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ''', (
+                    json.dumps(report),
+                    report["total_tests"],
+                    report["passed"],
+                    report["failed"],
+                    report["errors"],
+                    report["skipped"],
+                    report["total_time"],
+                    report["success_rate"],
+                    report["timestamp"]
+                ))
+            self._conn.commit()
+        except sqlite3.Error as e:
+            raise RuntimeError(f"Failed to insert report: {e}")
+
+    def getReportsWhere(self, where: Optional[str] = None, params: Optional[Tuple] = None) -> List[Tuple]:
+        """
+        Retrieves reports from the database table with optional WHERE conditions.
+        Args:
+            where (Optional[str]): SQL WHERE clause (without the 'WHERE' keyword).
+            params (Optional[Tuple]): Parameters to substitute in the WHERE clause.
+        Returns:
+            List[Tuple]: A list of tuples, each representing a row from the reports table.
+        Raises:
+            RuntimeError: If there is an error retrieving the reports from the database.
+        """
+        self.__connect()
+        try:
+            with closing(self._conn.cursor()) as cursor:
+                query = f'SELECT * FROM {self.TABLE_NAME}'
+                if where:
+                    query += f' WHERE {where}'
+                cursor.execute(query, params or ())
+                return cursor.fetchall()
+        except sqlite3.Error as e:
+            raise RuntimeError(f"Failed to retrieve reports: {e}")
+
+    def getReports(self) -> List[Tuple]:
+        """
+        Retrieves all reports from the database table.
+        Returns:
+            List[Tuple]: A list of tuples, each representing a row from the reports table.
+        Raises:
+            RuntimeError: If there is an error retrieving the reports from the database.
+        """
+
+        self.__connect()
+        try:
+            with closing(self._conn.cursor()) as cursor:
+                cursor.execute(f'SELECT * FROM {self.TABLE_NAME}')
+                return cursor.fetchall()
+        except sqlite3.Error as e:
+            raise RuntimeError(f"Failed to retrieve reports: {e}")
+
+    def resetDatabase(self) -> None:
+        """
+        Resets the database by dropping the table specified by TABLE_NAME if it exists.
+        This method establishes a connection to the database, attempts to drop the table,
+        and commits the changes. If an error occurs during the process, a RuntimeError is raised.
+        Raises:
+            RuntimeError: If the database reset operation fails.
+        """
+
+        self.__connect()
+        try:
+            with closing(self._conn.cursor()) as cursor:
+                cursor.execute(f'DROP TABLE IF EXISTS {self.TABLE_NAME}')
+            self._conn.commit()
+        except sqlite3.Error as e:
+            raise RuntimeError(f"Failed to reset database: {e}")
+
+    def close(self) -> None:
+        """
+        Closes the current database connection if it exists and sets the connection attribute to None.
+        """
+
+        if self._conn:
+            self._conn.close()
+            self._conn = None

{orionis-0.281.0 → orionis-0.283.0}/orionis/test/suites/test_suite.py

@@ -1,9 +1,9 @@
 import re
 from os import walk
 from orionis.foundation.config.testing.entities.testing import Testing as Configuration
+from orionis.test.exceptions.test_config_exception import OrionisTestConfigException
 from orionis.test.suites.contracts.test_suite import ITestSuite
 from orionis.test.suites.test_unit import UnitTest
-from orionis.test.exceptions.test_config_exception import OrionisTestConfigException
 
 class TestSuite(ITestSuite):
     """
@@ -27,7 +27,8 @@ class TestSuite(ITestSuite):
         Attributes:
             _config (Configuration): The configuration used by the object. If no configuration is provided, a new Configuration instance is created.
         """
-        self._config = config or Configuration()
+        self.__config = config or Configuration()
+        self.__result = None
 
     def run(self) -> UnitTest:
         """
@@ -42,7 +43,7 @@ class TestSuite(ITestSuite):
         """
 
         # Check if the config is provided
-        config = self._config
+        config = self.__config
 
         # Check if the config is an instance of Configuration
         if not isinstance(config, Configuration):
@@ -58,7 +59,8 @@ class TestSuite(ITestSuite):
             max_workers=config.max_workers,
             fail_fast=config.fail_fast,
             print_result=config.print_result,
-            throw_exception=config.throw_exception
+            throw_exception=config.throw_exception,
+            persistent=config.persistent,
         )
 
         # Extract configuration values
@@ -98,4 +100,14 @@ class TestSuite(ITestSuite):
             )
 
         # Return the initialized test suite
-        return tests.run()
+        self.__result = tests.run()
+        return self.__result
+
+    def getResult(self) -> UnitTest:
+        """
+        Returns the results of the executed test suite.
+
+        Returns:
+            UnitTest: The result of the executed test suite.
+        """
+        return self.__result