orionis 0.282.0__py3-none-any.whl → 0.283.0__py3-none-any.whl

orionis/application.py

@@ -1,15 +1,10 @@
 from orionis.foundation.config.startup import Configuration
+from orionis.patterns.singleton.meta_class import Singleton
 
-class Orionis:
+class Orionis(metaclass=Singleton):
 
     def __init__(
         self,
         config: Configuration = None
     ):
-        """
-        Initializes the Orionis instance with optional configuration objects.
-
-        Args:
-            config (Configuration, optional): Custom application configuration.
-        """
         self.__config = config or Configuration()

orionis/metadata/framework.py

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

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,13 +75,16 @@ 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)
-            set_key(str(self._resolved_path), key, f'"{serialized_value}"', quote_mode="never")
+            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/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/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/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/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):
@@ -99,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

orionis/test/suites/test_unit.py

@@ -14,7 +14,7 @@ from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.table import Table
 from orionis.console.output.console import Console
-from orionis.test.logs.log_test import LogTest
+from orionis.test.logs.history import TestHistory
 from orionis.test.suites.contracts.test_unit import IUnitTest
 from orionis.test.entities.test_result import TestResult
 from orionis.test.enums.test_mode import ExecutionMode
@@ -612,7 +612,7 @@ class UnitTest(IUnitTest):
             None
         """
         full_path = os.path.abspath(os.path.join(os.getcwd(), self.base_path))
-        log = LogTest(test_path_root=full_path)
+        log = TestHistory(full_path)
         try:
             log.createTableIfNotExists()
             log.insertReport(summary)

orionis/unittesting.py

@@ -3,6 +3,9 @@ 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
 
@@ -48,5 +51,6 @@ __all__ = [
     "UnittestTestResult",
     "UnittestMock",
     "UnittestMagicMock",
+    "TestHistory",
     "unittest_mock_patch",
-]
+]

{orionis-0.282.0.dist-info → orionis-0.283.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.282.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.282.0.dist-info → orionis-0.283.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/_application.py,sha256=dMjJ0nFcIIOBGb5zr-tHNzcgTOZ1vJ7iMdFAlqSQph0,9405
-orionis/application.py,sha256=KrIj21LSoQCrpkkc8O_UeHrEMEJvSGVJuMGx-srrOXE,413
-orionis/unittesting.py,sha256=VzNyVcLWTFP5dAWLQ_A1Zfzwv_Oeb9LbvNYNSbTEFbs,1626
+orionis/application.py,sha256=Off5uOUj-IYvvR8DcqLUoBW_98opWa7MQrtqTr0SZGc,292
+orionis/unittesting.py,sha256=am9rM3IcnG5NP_jA1Bj-VxjBGRTb0tGcehfkt9OoKGU,1761
 orionis/_container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/_container/container.py,sha256=0AOqTNwpN_OtWbq9mBI99qfJ7LMkN71y0lP0JWKzut0,18289
 orionis/_container/container_integrity.py,sha256=vrqZrkJaP6ghbiAzr-nEul9f_lEWVa2nMUSugQXDfWk,10095
@@ -226,7 +226,7 @@ orionis/foundation/config/testing/entities/testing.py,sha256=pIMb2DCwvu8K37ryiMX
 orionis/foundation/config/testing/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/testing/enums/test_mode.py,sha256=IbFpauu7J-iSAfmC8jDbmTEYl8eZr-AexL-lyOh8_74,337
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=iiVK0TMbgywwCmj-Hc3MX3kz129Ks9DKvrUs-eIvsRs,4960
+orionis/metadata/framework.py,sha256=coJ-vdD_2l2ZfOFX6TgRpUlhDKlYAg8GimtIagyREhs,4960
 orionis/metadata/package.py,sha256=5p4fxjPpaktsreJ458pAl-Oi1363MWACPQvqXi_N6oA,6704
 orionis/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/patterns/singleton/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -235,8 +235,8 @@ orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/async_io.py,sha256=22rHi-sIHL3ESHpxKFps8O-9O_5Uoq-BbtZpMmgFTrA,1023
 orionis/services/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/environment/dot_env.py,sha256=Ok3M-yKzsVcVFe6KTjqkuVe-3UTAuS-vnFSbKstetxY,9068
-orionis/services/environment/env.py,sha256=IV5iUQRwGOlL8P0xi4RL-ybc2qGRCXBMokRm2AuXhyc,2035
+orionis/services/environment/dot_env.py,sha256=PXU62gbOtzj-cZ4pt4dqYy17ywVVmomiSqUgXgcZm3M,9898
+orionis/services/environment/env.py,sha256=SQo6PRGlsYHcXzm8WU5ownoS4F9JzPs-nNT0b7_w_Mo,2099
 orionis/services/environment/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/environment/contracts/env.py,sha256=5g7jppzR5_ln8HlxJu2r0sSxLOkvBfSk3t4x_BKkYYk,1811
 orionis/services/introspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -313,20 +313,22 @@ orionis/test/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 orionis/test/exceptions/test_config_exception.py,sha256=yJv0JUTkZcF0Z4J8UHtffUipNgwNgmLhaqlOnnXFLyQ,995
 orionis/test/exceptions/test_failure_exception.py,sha256=pcMhzF1Z5kkJm4yM7gZiQI0SvGjKFixJkRd6VBE03AY,2199
 orionis/test/logs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/test/logs/log_test.py,sha256=dUFjtryTsptxipM7RY2fksv9CPtuvPq045Fx7kCaN0o,7176
+orionis/test/logs/history.py,sha256=8AqkCsGhd8S0PCBah2xFA0LN1YUnCmnwQvNmBmGmM2w,10097
+orionis/test/logs/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/test/logs/contracts/history.py,sha256=6L-ELdCcn1kdTKD9XRGuqeP1TuLQiLrOSanOnoaLrKg,2088
 orionis/test/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/output/dumper.py,sha256=pHD_HeokfWUydvaxxSvdJHdm2-VsrgL0PBr9ZSaavd8,3749
 orionis/test/output/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/output/contracts/dumper.py,sha256=ZpzlSJixGNbjFUVl53mCg_5djC-xwiit4ozQlzUps4g,1161
 orionis/test/suites/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/test/suites/test_suite.py,sha256=q3k-R40Vigh4xyXYHQdTAyShcqQeitH4oMKsQvUG8Kc,4871
-orionis/test/suites/test_unit.py,sha256=CUwjt-FeWLi7ME9xpwpGucEtC4TM6vPXEicaPCJBwyo,44593
+orionis/test/suites/test_suite.py,sha256=e8n9rDmym6Uj5D8E93ZUu_pQawKI-Gx5Fc1gaDlfN0o,5177
+orionis/test/suites/test_unit.py,sha256=hWtGRubx0iV0dOZrirrvjfTTZQQ1FYwoyxEicweuHmg,44585
 orionis/test/suites/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/suites/contracts/test_suite.py,sha256=arJSxWGjOHTVGiJrmqdqDrb9Ymt3SitDPZKVMBsWCf8,888
 orionis/test/suites/contracts/test_unit.py,sha256=5gaGXqCx07aDlAQJi8J-GF83kVj3uIx_fdPF1HYMKcg,5596
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/index.html,sha256=U4XYO4hA-mAJCK1gcVRgIysmISK3g3Vgi2ntLofFAhE,6592
-orionis-0.282.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.283.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/test_example.py,sha256=DUZU6lWVFsyHtBEXx0cBxMrSCpOtAOL3PUoi9-tXAas,583
@@ -390,7 +392,7 @@ tests/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/asynchrony/test_async_io.py,sha256=oS_PRgAluASK-7MEwEktRoPG6lSubWBPrtLMyhGOum4,1526
 tests/services/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/services/environment/test_env.py,sha256=Wk3TiaIUd_w-OWJQw82ZPZLv0-cfpi6dZcl0h0LD2MI,7063
+tests/services/environment/test_env.py,sha256=Fg4NejwmTdTTj4FezrWkJc639CzodGEgmdFa4EPlmqk,7084
 tests/services/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/inspection/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/inspection/dependencies/test_reflect_dependencies.py,sha256=z0C9KkhV27Y7jKpLSCN9XCmHbjJDCPbBb7NkRFs3oMI,5803
@@ -424,8 +426,8 @@ tests/support/inspection/fakes/fake_reflection_instance_with_abstract.py,sha256=
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/test_testing_result.py,sha256=54QDn6_v9feIcDcA6LPXcvYhlt_X8JqLGTYWS9XjKXM,3029
 tests/testing/test_testing_unit.py,sha256=MeVL4gc4cGRPXdVOOKJx6JPKducrZ8cN7F52Iiciixg,5443
-orionis-0.282.0.dist-info/METADATA,sha256=frb3YgJcrRlKnVfgTVaDpAGsv_rSkMstd4j7IRiuOZI,4772
-orionis-0.282.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-orionis-0.282.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.282.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.282.0.dist-info/RECORD,,
+orionis-0.283.0.dist-info/METADATA,sha256=7vHRB13iBUP3YekJnOOmvDd4coBejC3q-AHrsQzWr14,4772
+orionis-0.283.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+orionis-0.283.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.283.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.283.0.dist-info/RECORD,,

tests/services/environment/test_env.py

@@ -14,7 +14,7 @@ class TestEnv(TestCase):
         """
         with unittest_mock_patch.object(DotEnv, 'get', return_value='test_value') as mock_get:
             result = Env.get('TEST_KEY')
-            mock_get.assert_called_once_with('TEST_KEY', None)
+            mock_get.assert_called_once_with('TEST_KEY', None, False)
             self.assertEqual(result, 'test_value')
 
     async def testGetMethodWithDefault(self):
@@ -24,7 +24,7 @@ class TestEnv(TestCase):
         """
         with unittest_mock_patch.object(DotEnv, 'get', return_value='default_value') as mock_get:
             result = Env.get('NON_EXISTENT_KEY', 'default_value')
-            mock_get.assert_called_once_with('NON_EXISTENT_KEY', 'default_value')
+            mock_get.assert_called_once_with('NON_EXISTENT_KEY', 'default_value', False)
             self.assertEqual(result, 'default_value')
 
     async def testSetMethod(self):
@@ -34,7 +34,7 @@ class TestEnv(TestCase):
         """
         with unittest_mock_patch.object(DotEnv, 'set', return_value=True) as mock_set:
             result = Env.set('TEST_KEY', 'test_value')
-            mock_set.assert_called_once_with('TEST_KEY', 'test_value')
+            mock_set.assert_called_once_with('TEST_KEY', 'test_value', False)
             self.assertTrue(result)
 
     async def testUnsetMethod(self):

orionis/test/logs/log_test.py

@@ -1,211 +0,0 @@
-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
-
-class LogTest:
-    """
-    A utility class for managing test execution reports using a local SQLite database.
-
-    This class provides methods to create a report table, insert new test reports,
-    retrieve stored reports, reset the database, and close the connection.
-
-    Each test report is stored as a JSON string along with individual statistical fields
-    for easier filtering and analysis.
-
-    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_path_root: Optional[str] = None) -> None:
-        """
-        Initialize the LogTest instance and configure the database path.
-
-        Parameters
-        ----------
-        test_path_root : str, optional
-            Absolute or relative path to the directory where the SQLite file will be stored.
-            If None, the path is derived from the current file location.
-
-        Raises
-        ------
-        ValueError
-            If the path cannot be resolved correctly.
-        """
-        if test_path_root:
-            db_dir = Path(test_path_root).resolve()
-        else:
-            env_path = Env.get("TEST_PATH_ROOT")
-            if env_path:
-                db_dir = Path(env_path).resolve()
-            else:
-                db_dir = Path(__file__).resolve().parent
-
-        dbPath = db_dir.joinpath(self.DB_NAME)
-        Env.set("TEST_PATH_ROOT", str(dbPath).replace("\\", "\\\\"))
-        self._conn: Optional[sqlite3.Connection] = None
-
-    def __connect(self) -> None:
-        """
-        Establish a connection to the SQLite database.
-
-        Raises
-        ------
-        ConnectionError
-            If the connection to the database cannot be established.
-        """
-        if self._conn is None:
-            try:
-                self._conn = sqlite3.connect(Env.get("TEST_PATH_ROOT"))
-            except sqlite3.Error as e:
-                raise ConnectionError(f"Database connection error: {e}")
-
-    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.
-        """
-        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:
-        """
-        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.
-        """
-        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 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.
-        """
-        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:
-        """
-        Drop the `reportes` table, effectively clearing the report history.
-
-        Raises
-        ------
-        RuntimeError
-            If table deletion 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:
-        """
-        Close the SQLite database connection gracefully.
-        """
-        if self._conn:
-            self._conn.close()
-            self._conn = None