add CompatibleNullPool to handle pool sizing arguments and associated tests

Author: Eugene Shershen

psqlpy_sqlalchemy/__init__.py

@@ -2,5 +2,5 @@
 
 PsqlpyDialect = PSQLPyAsyncDialect
 
-__version__ = "0.1.0a4"
+__version__ = "0.1.0a5"
 __all__ = ["PsqlpyDialect", "PSQLPyAsyncDialect"]

psqlpy_sqlalchemy/dialect.py

@@ -6,14 +6,30 @@
 from sqlalchemy import URL, util
 from sqlalchemy.dialects.postgresql.base import INTERVAL, PGDialect
 from sqlalchemy.dialects.postgresql.json import JSONPathType
-from sqlalchemy.pool import AsyncAdaptedQueuePool
+from sqlalchemy.pool import AsyncAdaptedQueuePool, NullPool
 from sqlalchemy.sql import operators, sqltypes
 from sqlalchemy.sql.functions import GenericFunction
 
 from .connection import AsyncAdapt_psqlpy_connection, PGExecutionContext_psqlpy
 from .dbapi import PSQLPyAdaptDBAPI
 
 
+class CompatibleNullPool(NullPool):
+    """
+    A NullPool wrapper that accepts but ignores pool sizing arguments.
+    
+    This class is used to maintain compatibility with middleware that passes
+    pool_size and max_overflow arguments, which are not valid for NullPool
+    but are commonly passed by frameworks like FastAPI with fastapi_async_sqlalchemy.
+    """
+    
+    def __init__(self, creator, pool_size=None, max_overflow=None, **kw):
+        # Filter out pool sizing arguments that NullPool doesn't accept
+        filtered_kw = {k: v for k, v in kw.items() 
+                      if k not in ('pool_size', 'max_overflow')}
+        super().__init__(creator, **filtered_kw)
+
+
 # JSONB aggregation functions
 class jsonb_agg(GenericFunction):
     """JSONB aggregation function"""
@@ -262,6 +278,7 @@ def _isolation_lookup(self) -> Dict[str, Any]:
             "SERIALIZABLE": psqlpy.IsolationLevel.Serializable,
         }
 
+
     def create_connect_args(
         self,
         url: URL,
@@ -305,3 +322,6 @@ def get_deferrable(self, connection):
 
 # Backward compatibility alias for entry point system
 PsqlpyDialect = PSQLPyAsyncDialect
+
+# Export the compatible pool class for users who need it
+__all__ = ['PSQLPyAsyncDialect', 'PsqlpyDialect', 'CompatibleNullPool']

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "psqlpy-sqlalchemy"
-version = "0.1.0a4"
+version = "0.1.0a5"
 description = "SQLAlchemy dialect for psqlpy PostgreSQL driver"
 readme = "README.md"
 license = {text = "MIT"}

tests/test_poolclass_compatibility.py

@@ -12,7 +12,7 @@
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlalchemy.pool import AsyncAdaptedQueuePool, NullPool, QueuePool
 
-from psqlpy_sqlalchemy.dialect import PSQLPyAsyncDialect, PsqlpyDialect
+from psqlpy_sqlalchemy.dialect import PSQLPyAsyncDialect, PsqlpyDialect, CompatibleNullPool
 
 
 class TestPoolclassCompatibility(unittest.TestCase):
@@ -208,6 +208,82 @@ async def _test_explicit_nullpool():
         finally:
             loop.close()
 
+    def test_compatible_nullpool_with_pool_args_sync(self):
+        """Test that CompatibleNullPool works with pool arguments in sync engines"""
+        try:
+            self.engine = create_engine(
+                "postgresql+psqlpy://user:password@localhost/test",
+                poolclass=CompatibleNullPool,
+                pool_size=5,
+                max_overflow=10,
+            )
+            self.assertIsNotNone(self.engine.dialect)
+            self.assertEqual(self.engine.dialect.driver, "psqlpy")
+            self.assertEqual(self.engine.pool.__class__, CompatibleNullPool)
+        except Exception as e:
+            # Connection errors are acceptable, we're testing pool creation
+            if "Invalid argument(s)" in str(e):
+                self.fail(f"CompatibleNullPool should accept pool arguments: {e}")
+
+    def test_compatible_nullpool_with_pool_args_async(self):
+        """Test that CompatibleNullPool works with pool arguments in async engines"""
+
+        async def _test_compatible_nullpool():
+            try:
+                self.async_engine = create_async_engine(
+                    "postgresql+psqlpy://user:password@localhost/test",
+                    poolclass=CompatibleNullPool,
+                    pool_size=5,
+                    max_overflow=10,
+                )
+                self.assertIsNotNone(self.async_engine)
+                self.assertEqual(
+                    self.async_engine.sync_engine.pool.__class__, CompatibleNullPool
+                )
+                return True
+            except Exception as e:
+                # Connection errors are acceptable, we're testing pool creation
+                if "Invalid argument(s)" in str(e):
+                    self.fail(f"CompatibleNullPool should accept pool arguments: {e}")
+                return True
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            result = loop.run_until_complete(_test_compatible_nullpool())
+            self.assertTrue(result)
+        finally:
+            loop.close()
+
+    def test_compatible_nullpool_ignores_pool_args(self):
+        """Test that CompatibleNullPool ignores pool sizing arguments"""
+        try:
+            self.engine = create_engine(
+                "postgresql+psqlpy://user:password@localhost/test",
+                poolclass=CompatibleNullPool,
+                pool_size=100,  # Should be ignored
+                max_overflow=200,  # Should be ignored
+            )
+            # If we get here, the arguments were successfully ignored
+            self.assertIsNotNone(self.engine.dialect)
+            self.assertEqual(self.engine.pool.__class__, CompatibleNullPool)
+        except Exception as e:
+            # Connection errors are acceptable
+            if "Invalid argument(s)" in str(e):
+                self.fail(f"CompatibleNullPool should ignore pool arguments: {e}")
+
+    def test_regular_nullpool_still_fails_with_pool_args(self):
+        """Test that regular NullPool still fails with pool arguments (regression test)"""
+        with self.assertRaises(TypeError) as context:
+            self.engine = create_engine(
+                "postgresql+psqlpy://user:password@localhost/test",
+                poolclass=NullPool,
+                pool_size=5,
+                max_overflow=10,
+            )
+        
+        self.assertIn("Invalid argument(s) 'pool_size','max_overflow'", str(context.exception))
+
 
 class TestFastAPIMiddlewareCompatibility(unittest.TestCase):
     """Test cases for FastAPI middleware compatibility"""