orionis 0.281.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/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/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/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/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/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/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):
@@ -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

orionis/test/suites/test_unit.py

@@ -14,12 +14,14 @@ 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.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
 from orionis.test.enums.test_status import TestStatus
 from orionis.test.exceptions.test_failure_exception import OrionisTestFailureException
 from rich.live import Live
+import os
 
 class UnitTest(IUnitTest):
     """
@@ -64,6 +66,8 @@ class UnitTest(IUnitTest):
         self.discovered_tests: List = []
         self.width_output_component: int = int(self.rich_console.width * 0.75)
         self.throw_exception: bool = False
+        self.persistent: bool = False
+        self.base_path: str = "tests"
 
     def configure(
             self,
@@ -72,7 +76,8 @@ class UnitTest(IUnitTest):
             max_workers: int = None,
             fail_fast: bool = None,
             print_result: bool = None,
-            throw_exception: bool = False
+            throw_exception: bool = False,
+            persistent: bool = False
         ) -> 'UnitTest':
         """
         Configures the UnitTest instance with the specified parameters.
@@ -83,6 +88,8 @@ class UnitTest(IUnitTest):
             max_workers (int, optional): The maximum number of workers to use for parallel execution. Defaults to None.
             fail_fast (bool, optional): Whether to stop execution upon the first failure. Defaults to None.
             print_result (bool, optional): Whether to print the test results after execution. Defaults to None.
+            throw_exception (bool, optional): Whether to throw an exception if any test fails. Defaults to False.
+            persistent (bool, optional): Whether to persist the test results in a database. Defaults to False.
 
         Returns:
             UnitTest: The configured UnitTest instance.
@@ -107,6 +114,9 @@ class UnitTest(IUnitTest):
         if throw_exception is not None:
             self.throw_exception = throw_exception
 
+        if persistent is not None:
+            self.persistent = persistent
+
         return self
 
     def discoverTestsInFolder(
@@ -131,6 +141,8 @@ class UnitTest(IUnitTest):
             ValueError: If the test folder does not exist, no tests are found, or an error occurs during test discovery.
         """
         try:
+            self.base_path = base_path
+
             full_path = Path(base_path) / folder_path
             if not full_path.exists():
                 raise ValueError(f"Test folder not found: {full_path}")
@@ -290,9 +302,6 @@ class UnitTest(IUnitTest):
         if self.print_result:
             self._displayResults(summary, result)
 
-        # Generate performance report
-        summary["timestamp"] = datetime.now().isoformat()
-
         # Print Execution Time
         if not result.wasSuccessful() and self.throw_exception:
             raise OrionisTestFailureException(result)
@@ -446,6 +455,7 @@ class UnitTest(IUnitTest):
                         method=getattr(test, "_testMethodName", None),
                         module=getattr(test, "__module__", None),
                         file_path=inspect.getfile(test.__class__),
+                        doc_string=getattr(getattr(test, test._testMethodName, None), "__doc__", None),
                     )
                 )
 
@@ -466,6 +476,7 @@ class UnitTest(IUnitTest):
                         method=getattr(test, "_testMethodName", None),
                         module=getattr(test, "__module__", None),
                         file_path=inspect.getfile(test.__class__),
+                        doc_string=getattr(getattr(test, test._testMethodName, None), "__doc__", None),
                     )
                 )
 
@@ -486,6 +497,7 @@ class UnitTest(IUnitTest):
                         method=getattr(test, "_testMethodName", None),
                         module=getattr(test, "__module__", None),
                         file_path=inspect.getfile(test.__class__),
+                        doc_string=getattr(getattr(test, test._testMethodName, None), "__doc__", None),
                     )
                 )
 
@@ -503,6 +515,7 @@ class UnitTest(IUnitTest):
                         method=getattr(test, "_testMethodName", None),
                         module=getattr(test, "__module__", None),
                         file_path=inspect.getfile(test.__class__),
+                        doc_string=getattr(getattr(test, test._testMethodName, None), "__doc__", None),
                     )
                 )
 
@@ -533,11 +546,8 @@ class UnitTest(IUnitTest):
                     - "error_message" (str): The error message if the test failed or errored.
                     - "traceback" (str): The traceback information if the test failed or errored.
                     - "file_path" (str): The file path of the test.
-                - "performance_data" (List[Dict[str, float]]): A list containing performance data:
-                    - "duration" (float): The total execution time of the test suite.
         """
         test_details = []
-        performance_data = []
 
         for test_result in result.test_results:
             rst: TestResult = test_result
@@ -549,28 +559,66 @@ class UnitTest(IUnitTest):
                 'execution_time': float(rst.execution_time),
                 'error_message': rst.error_message,
                 'traceback': rst.traceback,
-                'file_path': rst.file_path
+                'file_path': rst.file_path,
+                'doc_string': rst.doc_string
             })
 
-        performance_data.append({
-            'duration': float(execution_time)
-        })
-
         passed = result.testsRun - len(result.failures) - len(result.errors) - len(result.skipped)
         success_rate = (passed / result.testsRun * 100) if result.testsRun > 0 else 100.0
 
-        return {
+        # Create a summary report
+        report = {
             "total_tests": result.testsRun,
             "passed": passed,
             "failed": len(result.failures),
             "errors": len(result.errors),
             "skipped": len(result.skipped),
-            "total_time": execution_time,
+            "total_time": float(execution_time),
             "success_rate": success_rate,
             "test_details": test_details,
-            "performance_data": performance_data
+            "timestamp": datetime.now().isoformat()
+        }
+
+        # Handle persistence of the report
+        if self.persistent:
+            self._persistTestResults(report)
+
+        # Return the summary
+        return {
+            "total_tests": result.testsRun,
+            "passed": passed,
+            "failed": len(result.failures),
+            "errors": len(result.errors),
+            "skipped": len(result.skipped),
+            "total_time": float(execution_time),
+            "success_rate": success_rate,
+            "test_details": test_details
         }
 
+    def _persistTestResults(self, summary: Dict[str, Any]) -> None:
+        """
+        Persists the test results in a SQLite database.
+        Args:
+            summary (Dict[str, Any]): A dictionary containing the test summary data.
+                Expected keys in the dictionary:
+                    - "total_tests" (int): Total number of tests executed.
+                    - "passed" (int): Number of tests that passed.
+                    - "failed" (int): Number of tests that failed.
+                    - "errors" (int): Number of tests that encountered errors.
+                    - "skipped" (int): Number of tests that were skipped.
+                    - "total_time" (float): Total duration of the test run in seconds.
+                    - "success_rate" (float): Percentage of tests that passed.
+        Returns:
+            None
+        """
+        full_path = os.path.abspath(os.path.join(os.getcwd(), self.base_path))
+        log = TestHistory(full_path)
+        try:
+            log.createTableIfNotExists()
+            log.insertReport(summary)
+        finally:
+            log.close()
+
     def _printSummaryTable(self, summary: Dict[str, Any]) -> None:
         """
         Prints a summary table of test results using the Rich library.

orionis/test/view/index.html

@@ -0,0 +1,127 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Orionis Test Dashboard</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link rel="icon" href="https://orionis-framework.com/svg/logo.svg" />
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.min.css">
+</head>
+
+<body class="bg-gray-100 text-gray-800 font-sans">
+    <div class="max-w-7xl mx-auto px-4 sm:px-6 py-8">
+
+        <!-- Header -->
+        <header class="bg-gradient-to-r from-blue-900 to-cyan-400 text-white rounded-2xl shadow-xl p-6 mb-10">
+            <div class="flex flex-col md:flex-row justify-between items-center gap-4">
+                <div class="flex items-center gap-4">
+                    <img src="https://orionis-framework.com/svg/logo.svg" alt="Orionis Logo"
+                        class="h-10 brightness-0 invert" />
+                    <h1 class="text-2xl font-light tracking-wider">Orionis Testing Results Dashboard</h1>
+                </div>
+                <div id="timestamp" class="text-sm text-white/90"></div>
+            </header>
+
+            <!-- Execution Summary Card -->
+            <div class="w-full mb-10">
+                <div class="bg-white rounded-2xl shadow-lg p-6 border-t-4 border-indigo-500 flex flex-col sm:flex-row items-center justify-between gap-4">
+                    <div>
+                        <div class="text-xs font-semibold text-gray-500 uppercase">Resumen de Ejecución</div>
+                        <div class="text-lg font-bold text-gray-800 mt-2" id="execution-summary-title">Ejecución Completa</div>
+                        <div class="text-sm text-gray-600 mt-1" id="execution-summary-desc">Todos los tests han sido ejecutados correctamente.</div>
+                    </div>
+                    <div class="flex items-center gap-4">
+                        <div class="flex items-center gap-1 text-gray-700">
+                            <i class="bi bi-clock-history text-xl text-indigo-500"></i>
+                            <span id="execution-time">Duración: 00:00:00</span>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Summary Cards -->
+            <div class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-6 mb-10">
+
+            <div class="bg-white rounded-2xl shadow-lg p-6 border-t-4 border-green-500">
+                <div class="text-xs font-semibold text-gray-500 uppercase">Passed</div>
+                <div class="text-4xl font-bold text-gray-800 mt-2" id="passed">0</div>
+                <div class="mt-4 bg-gray-200 rounded-full h-2">
+                    <div class="bg-green-500 h-2 rounded-full" id="passed-progress" style="width: 0%"></div>
+                </div>
+            </div>
+
+            <div class="bg-white rounded-2xl shadow-lg p-6 border-t-4 border-red-500">
+                <div class="text-xs font-semibold text-gray-500 uppercase">Failed</div>
+                <div class="text-4xl font-bold text-gray-800 mt-2" id="failed">0</div>
+            </div>
+
+            <div class="bg-white rounded-2xl shadow-lg p-6 border-t-4 border-yellow-500">
+                <div class="text-xs font-semibold text-gray-500 uppercase">Errors</div>
+                <div class="text-4xl font-bold text-gray-800 mt-2" id="errors">0</div>
+            </div>
+
+            <div class="bg-white rounded-2xl shadow-lg p-6 border-t-4 border-blue-500">
+                <div class="text-xs font-semibold text-gray-500 uppercase">Skipped</div>
+                <div class="text-4xl font-bold text-gray-800 mt-2" id="skipped">0</div>
+            </div>
+
+        </div>
+
+        <!-- Download Buttons & Select -->
+        <div class="flex flex-wrap justify-between items-center mb-10 gap-4">
+            <!-- Buttons to the left -->
+            <div class="flex flex-wrap gap-4">
+                <button id="download-json"
+                    class="flex items-center gap-2 bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded shadow">
+                    <i class="bi bi-file-earmark-code-fill text-lg"></i>
+                    <span>Download JSON</span>
+                </button>
+                <button id="download-excel"
+                    class="flex items-center gap-2 bg-green-600 hover:bg-green-700 text-white px-4 py-2 rounded shadow">
+                    <i class="bi bi-file-earmark-excel-fill text-lg"></i>
+                    <span>Download Excel</span>
+                </button>
+                <button id="download-pdf"
+                    class="flex items-center gap-2 bg-red-600 hover:bg-red-700 text-white px-4 py-2 rounded shadow">
+                    <i class="bi bi-file-earmark-pdf-fill text-lg"></i>
+                    <span>Download PDF</span>
+                </button>
+            </div>
+            <!-- Elegant Select to the right -->
+            <div>
+                <select
+                    class="appearance-none bg-white border border-gray-300 text-gray-700 py-2 px-4 pr-10 rounded-lg shadow focus:outline-none focus:ring-2 focus:ring-blue-400 focus:border-blue-400 transition text-base font-medium">
+                    <option selected disabled>Selecciona una opción</option>
+                    <option>Opción 1</option>
+                    <option>Opción 2</option>
+                    <option>Opción 3</option>
+                </select>
+            </div>
+        </div>
+
+        <!-- JSON Viewer Panel -->
+        <div class="bg-white rounded-2xl shadow-xl p-6">
+            <h2 class="text-xl font-semibold mb-4">Test Report JSON</h2>
+            <pre id="json-data"
+                class="whitespace-pre-wrap text-sm text-gray-800 bg-gray-100 p-4 rounded-xl overflow-x-auto"></pre>
+        </div>
+
+        <!-- Footer -->
+        <footer class="mt-12 text-center text-gray-500 text-sm py-6">
+            Developed with the power of
+            <a href="https://orionis-framework.com/" target="_blank" rel="noopener"
+                class="font-semibold text-blue-700 hover:underline">
+                Orionis Framework
+            </a>
+            <i class="bi bi-stars text-yellow-400 align-middle ml-1"></i>
+        </footer>
+
+        <script>
+            // Placeholder JS logic
+            document.getElementById("timestamp").textContent = new Date().toLocaleString();
+        </script>
+</body>
+
+</html>

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.281.0.dist-info → orionis-0.283.0.dist-info}/METADATA

@@ -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.281.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
@@ -222,11 +222,11 @@ orionis/foundation/config/session/enums/same_site_policy.py,sha256=Oo05CJ-5keJWz
 orionis/foundation/config/session/helpers/secret_key.py,sha256=yafjzQ9KVQdXzCQCMthpgizlNCo5F5UTLtAnInipUMk,447
 orionis/foundation/config/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/testing/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/foundation/config/testing/entities/testing.py,sha256=C_T054W0jv29JUH9aiK0mIDMa6yJyGYjsmEx5p4zVyE,10001
+orionis/foundation/config/testing/entities/testing.py,sha256=pIMb2DCwvu8K37ryiMXqOcS4VGDw0W8dJD-N37na8LM,10251
 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=SlTVFOuVJGZLeCZMsckhJOaW1jUWkTQ0Di4vE20nYbw,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=nnkrQBG3rZr_RjnBQLfczoDl2ailRwRU0OOuIRH70AY,9041
-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
@@ -305,24 +305,30 @@ orionis/test/cases/test_async.py,sha256=YwycimGfUx9-kd_FFO8BZXyVayYwOBOzxbu3WZU_
 orionis/test/cases/test_case.py,sha256=GVN3cxYuE47uPOEqFUiMreLdXjTyqzHjjxfyEM5_D4w,1446
 orionis/test/cases/test_sync.py,sha256=FekXNQDq5pOQB2YpvP7E9jAqIJH9uZhTMoPz-qx8FO0,742
 orionis/test/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/test/entities/test_result.py,sha256=iubNbW725p0llOg6-o9s4gRkq6iNnlufFGxNApik5Jg,1926
+orionis/test/entities/test_result.py,sha256=4ZThMeYRus6Vabnn2MW4hFztIRJA0_W5R2rSJIw90Ho,2095
 orionis/test/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/enums/test_mode.py,sha256=CHstYZ180MEX84AjZIoyA1l8gKxFLp_eciLOj2in57E,481
 orionis/test/enums/test_status.py,sha256=vNKRmp1lud_ZGTayf3A8wO_0vEYdFABy_oMw-RcEc1c,673
 orionis/test/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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/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=H7prpaZJUMcMUBWvBatejxAJh3lToNHYwYSAHISlTuc,4827
-orionis/test/suites/test_unit.py,sha256=ldlIQwCcHXmqFMRZ3XMwF9AKJC9pTYuUsBKKRE51jpA,42299
+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-0.281.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/test/view/index.html,sha256=U4XYO4hA-mAJCK1gcVRgIysmISK3g3Vgi2ntLofFAhE,6592
+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
@@ -386,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
@@ -420,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.281.0.dist-info/METADATA,sha256=ewjvEk14IPdK37_Vsmpwq0USGt53y9xRirPXHKwXda8,4772
-orionis-0.281.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-orionis-0.281.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.281.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.281.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):