Merge pull request #948 from circulon/fix/947

eaguad1337 · web-flow · commit 0e5e29f37c01 · 2025-12-02T13:13:41.000-03:00
Fix/947
diff --git a/orm.sqlite3 b/orm.sqlite3
diff --git a/pytest.ini b/pytest.ini
@@ -1,3 +1,3 @@
 [pytest]
-env = 
-    D:DB_CONFIG_PATH=config/test-database
+env =
+    D:DB_CONFIG_PATH=tests/integrations/config/database
diff --git a/requirements.txt b/requirements.txt
@@ -3,6 +3,7 @@ black
 isort
 faker
 pytest
+pytest-env
 pytest-cov
 pymysql
 inflection>=0.3
diff --git a/src/masoniteorm/connections/ConnectionFactory.py b/src/masoniteorm/connections/ConnectionFactory.py
@@ -1,13 +1,15 @@
 from ..config import load_config
+from .ConnectionResolver import ConnectionResolver
 
 
 class ConnectionFactory:
     """Class for controlling the registration and creation of connection types."""
 
     _connections = {}
 
-    def __init__(self, config_path=None):
+    def __init__(self, config_path=None, resolver=None):
         self.config_path = config_path
+        self._resolver: ConnectionResolver = resolver
 
     @classmethod
     def register(cls, key, connection):
@@ -35,18 +37,16 @@ def make(self, key):
         Returns:
             masoniteorm.connection.BaseConnection -- Returns an instance of a BaseConnection class.
         """
+        if not self._resolver:
+            self._resolver = load_config(config_path=self.config_path).DB
 
-        DB = load_config(config_path=self.config_path).DB
-
-        connections = DB.get_connection_details()
-
+        connections = self._resolver.get_connection_details()
         if key == "default":
             connection_details = connections.get(connections.get("default"))
             connection = self._connections.get(
                 connection_details.get("driver")
             )
         else:
-            connection_details = connections.get(key)
             connection = self._connections.get(key)
 
         if connection:
diff --git a/src/masoniteorm/connections/ConnectionResolver.py b/src/masoniteorm/connections/ConnectionResolver.py
@@ -2,22 +2,24 @@
 
 
 class ConnectionResolver:
-    _connection_details = {}
     _connections = {}
     _morph_map = {}
 
-    def __init__(self, config_path=None):
+    def __init__(self, config_path=None, connection_details=None):
         from ..connections import (
+            ConnectionFactory,
             MSSQLConnection,
             MySQLConnection,
             PostgresConnection,
             SQLiteConnection,
         )
 
         self.config_path = config_path
-        from ..connections import ConnectionFactory
+        self._connection_details = connection_details or {}
 
-        self.connection_factory = ConnectionFactory(config_path=config_path)
+        self.connection_factory = ConnectionFactory(
+            config_path=config_path, resolver=self
+        )
         self.register(SQLiteConnection)
         self.register(PostgresConnection)
         self.register(MySQLConnection)
@@ -28,7 +30,7 @@ def morph_map(self, map):
         return self
 
     def set_connection_details(self, connection_details):
-        self.__class__._connection_details = connection_details
+        self._connection_details = connection_details
         return self
 
     def get_connection_details(self):
diff --git a/src/masoniteorm/models/Model.py b/src/masoniteorm/models/Model.py
@@ -392,8 +392,8 @@ def get_columns(cls):
         return list(cls.first().__attributes__.keys())
 
     def get_connection_details(self):
-        DB = load_config().DB
-        return DB.get_connection_details()
+        resolver = load_config().DB
+        return resolver.get_connection_details()
 
     def boot(self):
         if not self._booted:
diff --git a/src/masoniteorm/query/QueryBuilder.py b/src/masoniteorm/query/QueryBuilder.py
@@ -5,6 +5,7 @@
 
 from ..collection.Collection import Collection
 from ..config import load_config
+from ..connections import ConnectionResolver
 from ..exceptions import (
     HTTP404,
     ConnectionNotRegistered,
@@ -107,8 +108,8 @@ def __init__(
         self.set_action("select")
 
         if not self._connection_details:
-            DB = load_config(config_path=self.config_path).DB
-            self._connection_details = DB.get_connection_details()
+            resolver = load_config(config_path=self.config_path).DB
+            self._connection_details = resolver.get_connection_details()
 
         self.on(connection)
 
@@ -398,8 +399,6 @@ def method(*args, **kwargs):
         )
 
     def on(self, connection):
-        DB = load_config(self.config_path).DB
-
         if connection == "default":
             self.connection = self._connection_details.get("default")
         else:
@@ -413,7 +412,10 @@ def on(self, connection):
         self._connection_driver = self._connection_details.get(
             self.connection
         ).get("driver")
-        self.connection_class = DB.connection_factory.make(
+        resolver = ConnectionResolver(
+            connection_details=self._connection_details
+        )
+        self.connection_class = resolver.connection_factory.make(
             self._connection_driver
         )
 
diff --git a/src/masoniteorm/schema/Schema.py b/src/masoniteorm/schema/Schema.py
@@ -87,23 +87,22 @@ def on(self, connection_key):
         Returns:
             cls
         """
-        DB = load_config(config_path=self.config_path).DB
-
+        resolver = load_config(config_path=self.config_path).DB
+        self.connection_details = resolver.get_connection_details()
         if connection_key == "default":
             self.connection = self.connection_details.get("default")
+        else:
+            self.connection = connection_key
 
-        connection_detail = self._connection_driver = (
-            self.connection_details.get(self.connection)
-        )
-
+        connection_detail = self.connection_details.get(self.connection)
         if connection_detail:
             self._connection_driver = connection_detail.get("driver")
         else:
             raise ConnectionNotRegistered(
                 f"Could not find the '{connection_key}' connection details"
             )
 
-        self.connection_class = DB.connection_factory.make(
+        self.connection_class = resolver.connection_factory.make(
             self._connection_driver
         )
 
diff --git a/tests/config/test_db_url.py b/tests/config/test_db_url.py
@@ -117,7 +117,12 @@ def test_using_it_with_connection_resolver(self):
         assert config.get("port") == 3306
         assert config.get("host") == "localhost"
         assert config.get("log_queries")
-        # reset connection resolver to default for other tests to continue working
-        from tests.integrations.config.database import DATABASES
 
-        ConnectionResolver().set_connection_details(DATABASES)
+        inline_resolver = ConnectionResolver(connection_details=TEST_DATABASES)
+        inline_config = inline_resolver.get_connection_details().get("test")
+        assert inline_config.get("database") == "orm"
+        assert inline_config.get("user") == "root"
+        assert inline_config.get("password") == ""
+        assert inline_config.get("port") == 3306
+        assert inline_config.get("host") == "localhost"
+        assert inline_config.get("log_queries")
diff --git a/tests/integrations/config/database.py b/tests/integrations/config/database.py
@@ -119,7 +119,7 @@
     },
 }
 
-DB = ConnectionResolver().set_connection_details(DATABASES)
+DB = ConnectionResolver(connection_details=DATABASES)
 
 logger = logging.getLogger("masoniteorm.connection.queries")
 logger.setLevel(logging.DEBUG)
diff --git a/tests/sqlite/builder/test_sqlite_builder_insert.py b/tests/sqlite/builder/test_sqlite_builder_insert.py
@@ -4,7 +4,7 @@
 from src.masoniteorm.models import Model
 from src.masoniteorm.query import QueryBuilder
 from src.masoniteorm.query.grammars import SQLiteGrammar
-from tests.integrations.config.database import DATABASES
+from tests.integrations.config.database import DB
 
 
 class User(Model):
@@ -13,18 +13,18 @@ class User(Model):
     pass
 
 
-class BaseTestQueryRelationships(unittest.TestCase):
+class SqliteTestQueryBuilderInsert(unittest.TestCase):
     maxDiff = None
 
     def get_builder(self, table="users"):
-        connection = ConnectionFactory().make("sqlite")
+        connection = ConnectionFactory(resolver=DB).make("sqlite")
         return QueryBuilder(
             grammar=SQLiteGrammar,
             connection_class=connection,
             connection="dev",
             table=table,
-            connection_details=DATABASES,
-        ).on("dev")
+            connection_details=DB.get_connection_details(),
+        )
 
     def test_insert(self):
         builder = self.get_builder()
diff --git a/tests/sqlite/builder/test_sqlite_builder_pagination.py b/tests/sqlite/builder/test_sqlite_builder_pagination.py
@@ -4,26 +4,26 @@
 from src.masoniteorm.models import Model
 from src.masoniteorm.query import QueryBuilder
 from src.masoniteorm.query.grammars import SQLiteGrammar
-from tests.integrations.config.database import DATABASES
+from tests.integrations.config.database import DB
 
 
 class User(Model):
     __connection__ = "dev"
 
 
-class BaseTestQueryRelationships(unittest.TestCase):
+class SqliteQueryBuilderPagination(unittest.TestCase):
     maxDiff = None
 
-    def get_builder(self, table="users", model=User()):
-        connection = ConnectionFactory().make("sqlite")
+    def get_builder(self, table="users", model=User):
+        connection = ConnectionFactory(resolver=DB).make("sqlite")
         return QueryBuilder(
             grammar=SQLiteGrammar,
             connection_class=connection,
             connection="dev",
             table=table,
-            model=model,
-            connection_details=DATABASES,
-        ).on("dev")
+            model=model(),
+            connection_details=DB.get_connection_details(),
+        )
 
     def test_pagination(self):
         builder = self.get_builder()
diff --git a/tests/sqlite/builder/test_sqlite_query_builder.py b/tests/sqlite/builder/test_sqlite_query_builder.py
@@ -1,7 +1,18 @@
 import inspect
+import os
 import unittest
-
-from src.masoniteorm.exceptions import HTTP404, ModelNotFound
+from pathlib import Path
+
+import pytest
+
+from src.masoniteorm.config import load_config
+from src.masoniteorm.connections import ConnectionResolver
+from src.masoniteorm.exceptions import (
+    HTTP404,
+    ConfigurationNotFound,
+    ModelNotFound,
+    QueryException,
+)
 from src.masoniteorm.models import Model
 from src.masoniteorm.query import QueryBuilder
 from src.masoniteorm.query.grammars import SQLiteGrammar
@@ -25,6 +36,37 @@ def get_builder(self, table="users"):
             dry=True,
         )
 
+    def test_standalone_connection_details(self):
+        # clear the env config path
+        current_path = os.environ.pop("DB_CONFIG_PATH", None)
+        # test we fail to load the default config
+        with pytest.raises(ConfigurationNotFound):
+            load_config()
+
+        custom_details = {
+            "default": "test",
+            "test": {
+                "driver": "sqlite",
+                "database": "config_test.sqlite3",
+            },
+        }
+
+        resolver = ConnectionResolver(connection_details=custom_details)
+        connection = resolver.connection_factory.make("sqlite")
+        builder = QueryBuilder(
+            connection_details=custom_details,
+            connection_class=connection,
+        )
+        with pytest.raises(QueryException) as query_exc:
+            builder.table("tests").all()
+        self.assertIn("'no such table: tests'", str(query_exc))
+
+        # remove the test file
+        (Path().cwd() / "config_test.sqlite3").unlink()
+
+        # reset the config path for other tests to use
+        os.environ["DB_CONFIG_PATH"] = current_path
+
     def test_sum(self):
         builder = self.get_builder()
         builder.sum("age")
diff --git a/tests/sqlite/builder/test_sqlite_query_builder_eager_loading.py b/tests/sqlite/builder/test_sqlite_query_builder_eager_loading.py
@@ -1,10 +1,11 @@
 import unittest
 
+from src.masoniteorm.connections import ConnectionFactory
 from src.masoniteorm.models import Model
 from src.masoniteorm.query import QueryBuilder
 from src.masoniteorm.query.grammars import SQLiteGrammar
 from src.masoniteorm.relationships import belongs_to, has_many
-from tests.integrations.config.database import DATABASES
+from tests.integrations.config.database import DB
 
 
 class Logo(Model):
@@ -52,16 +53,18 @@ def profile(self):
         return Profile
 
 
-class BaseTestQueryRelationships(unittest.TestCase):
+class SqliteTestQueryBuilderEagerLoading(unittest.TestCase):
     maxDiff = None
 
-    def get_builder(self, table="users", model=User()):
+    def get_builder(self, table="users", model=User):
+        connection = ConnectionFactory(resolver=DB).make("sqlite")
         return QueryBuilder(
             grammar=SQLiteGrammar,
+            connection_class=connection,
             connection="dev",
             table=table,
-            model=model,
-            connection_details=DATABASES,
+            model=model(),
+            connection_details=DB.get_connection_details(),
         ).on("dev")
 
     def test_with(self):
diff --git a/tests/sqlite/builder/test_sqlite_query_builder_relationships.py b/tests/sqlite/builder/test_sqlite_query_builder_relationships.py
diff --git a/tests/sqlite/builder/test_sqlite_transaction.py b/tests/sqlite/builder/test_sqlite_transaction.py
diff --git a/tests/sqlite/models/test_observers.py b/tests/sqlite/models/test_observers.py
diff --git a/tests/sqlite/models/test_sqlite_model.py b/tests/sqlite/models/test_sqlite_model.py

Original file line number	Diff line number	Diff line change
`@@ -119,7 +119,7 @@`
`119`	`119`	`},`
`120`	`120`	`}`
`121`	`121`
`122`		`-DB = ConnectionResolver().set_connection_details(DATABASES)`
	`122`	`+DB = ConnectionResolver(connection_details=DATABASES)`
`123`	`123`
`124`	`124`	`logger = logging.getLogger("masoniteorm.connection.queries")`
`125`	`125`	`logger.setLevel(logging.DEBUG)`