Fix CI failures: Handle optional dependencies and SSL in tests

- Add proper optional import handling for psycopg2, psycopg, and asyncpg
- Fix asyncpg SSL connection issue by explicitly disabling SSL
- Make multiple clients test handle missing dependencies gracefully
- Fix trailing whitespace in config.py
- Update test logic to work with any combination of available drivers

Co-authored-by: wey-gu <1651790+wey-gu@users.noreply.github.com>

Author: Copilot

src/py_pglite/config.py

@@ -91,7 +91,7 @@ def get_connection_string(self) -> str:
         if self.use_tcp:
             # TCP connection string
             return f"postgresql+psycopg://postgres:postgres@{self.tcp_host}:{self.tcp_port}/postgres?sslmode=disable"
-        
+
         # For SQLAlchemy with Unix domain sockets, we need to specify the directory
         # and use the standard PostgreSQL socket naming convention
         socket_dir = str(Path(self.socket_path).parent)
@@ -108,7 +108,7 @@ def get_psycopg_uri(self) -> str:
         if self.use_tcp:
             # TCP URI
             return f"postgresql://postgres:postgres@{self.tcp_host}:{self.tcp_port}/postgres?sslmode=disable"
-        
+
         socket_dir = str(Path(self.socket_path).parent)
         # Use standard PostgreSQL URI format for psycopg
         return f"postgresql://postgres:postgres@/postgres?host={socket_dir}"
@@ -118,21 +118,21 @@ def get_dsn(self) -> str:
         if self.use_tcp:
             # TCP DSN
             return f"host={self.tcp_host} port={self.tcp_port} dbname=postgres user=postgres password=postgres sslmode=disable"
-        
+
         socket_dir = str(Path(self.socket_path).parent)
         # Use key-value format for psycopg DSN, including password
         return f"host={socket_dir} dbname=postgres user=postgres password=postgres"
 
     def get_asyncpg_uri(self) -> str:
         """Get PostgreSQL URI for asyncpg usage.
-        
+
         Returns:
             PostgreSQL URI string compatible with asyncpg.connect()
         """
         if self.use_tcp:
             # TCP URI (asyncpg doesn't support sslmode parameter)
             return f"postgresql://postgres:postgres@{self.tcp_host}:{self.tcp_port}/postgres"
-        
+
         # Unix socket URI
         socket_dir = str(Path(self.socket_path).parent)
         return f"postgresql://postgres:postgres@/postgres?host={socket_dir}"

tests/test_tcp_socket_support.py

@@ -2,18 +2,36 @@
 
 import asyncio
 import json
+
 from io import StringIO
 
-import asyncpg
-import psycopg
 import pytest
-from sqlalchemy import create_engine, text
+
+from sqlalchemy import create_engine
+from sqlalchemy import text
 from sqlalchemy.pool import StaticPool
 
 from py_pglite import PGliteConfig
 from py_pglite import PGliteManager
 
 
+# Optional dependencies - only import if available
+try:
+    import asyncpg
+except ImportError:
+    asyncpg = None
+
+try:
+    import psycopg
+except ImportError:
+    psycopg = None
+
+try:
+    import psycopg2
+except ImportError:
+    psycopg2 = None
+
+
 class TestTCPSocketConfiguration:
     """Test TCP socket configuration and validation."""
 
@@ -337,7 +355,7 @@ def test_sqlalchemy_tcp_mode(self):
 
                 conn.commit()
 
-
+    @pytest.mark.skipif(asyncpg is None, reason="asyncpg not available")
     def test_asyncpg_tcp_mode(self):
         """Test asyncpg connectivity in TCP mode."""
 
@@ -352,8 +370,8 @@ async def run_asyncpg_test():
                 assert "127.0.0.1:15443" in uri
                 assert "postgresql://postgres:postgres@" in uri
 
-                # Connect with asyncpg
-                conn = await asyncpg.connect(uri)
+                # Connect with asyncpg - disable SSL since PGlite doesn't support it
+                conn = await asyncpg.connect(uri, ssl=False)
                 try:
                     # Test SELECT
                     result = await conn.fetchval("SELECT 1")
@@ -423,37 +441,64 @@ def test_multiple_clients_tcp_mode(self):
         config = PGliteConfig(use_tcp=True, tcp_port=15444)
 
         with PGliteManager(config) as manager:
-            # Test psycopg2
-            conn2 = psycopg2.connect(manager.get_dsn())
-            cur2 = conn2.cursor()
-            cur2.execute("CREATE TABLE multi_client (id INT, client TEXT)")
-            cur2.execute("INSERT INTO multi_client VALUES (1, 'psycopg2')")
-            conn2.commit()
-            cur2.close()
-            conn2.close()
-
-            # Test psycopg3
-            with psycopg.connect(manager.get_dsn()) as conn3:
-                with conn3.cursor() as cur3:
-                    cur3.execute("INSERT INTO multi_client VALUES (2, 'psycopg3')")
-                    conn3.commit()
-
-            # Test SQLAlchemy
+            clients_tested = []
+
+            # Test psycopg2 (if available)
+            if psycopg2 is not None:
+                conn2 = psycopg2.connect(manager.get_dsn())
+                cur2 = conn2.cursor()
+                cur2.execute("CREATE TABLE multi_client (id INT, client TEXT)")
+                cur2.execute("INSERT INTO multi_client VALUES (1, 'psycopg2')")
+                conn2.commit()
+                cur2.close()
+                conn2.close()
+                clients_tested.append("psycopg2")
+
+            # Test psycopg3 (if available)
+            if psycopg is not None:
+                with psycopg.connect(manager.get_dsn()) as conn3:
+                    with conn3.cursor() as cur3:
+                        # Create table if it doesn't exist (in case psycopg2 wasn't available)
+                        if not clients_tested:
+                            cur3.execute(
+                                "CREATE TABLE multi_client (id INT, client TEXT)"
+                            )
+                        cur3.execute("INSERT INTO multi_client VALUES (2, 'psycopg3')")
+                        conn3.commit()
+                clients_tested.append("psycopg3")
+
+            # Test SQLAlchemy (always available since it's imported directly)
             engine = create_engine(
                 manager.get_connection_string(), poolclass=StaticPool
             )
             with engine.connect() as conn_sa:
+                # Create table if it doesn't exist (in case no psycopg was available)
+                if not clients_tested:
+                    conn_sa.execute(
+                        text("CREATE TABLE multi_client (id INT, client TEXT)")
+                    )
                 conn_sa.execute(
                     text("INSERT INTO multi_client VALUES (3, 'sqlalchemy')")
                 )
                 conn_sa.commit()
-
-            # Verify all inserts with psycopg3
-            with psycopg.connect(manager.get_dsn()) as conn:
-                with conn.cursor() as cur:
-                    cur.execute("SELECT COUNT(*) FROM multi_client")
-                    assert cur.fetchone()[0] == 3
-
-                    cur.execute("SELECT client FROM multi_client ORDER BY id")
-                    clients = [row[0] for row in cur.fetchall()]
-                    assert clients == ["psycopg2", "psycopg3", "sqlalchemy"]
+            clients_tested.append("sqlalchemy")
+
+            # Verify inserts (use psycopg3 if available, otherwise SQLAlchemy)
+            if psycopg is not None:
+                with psycopg.connect(manager.get_dsn()) as conn:
+                    with conn.cursor() as cur:
+                        cur.execute("SELECT COUNT(*) FROM multi_client")
+                        expected_count = len(clients_tested)
+                        assert cur.fetchone()[0] == expected_count
+
+                        cur.execute("SELECT client FROM multi_client ORDER BY id")
+                        actual_clients = [row[0] for row in cur.fetchall()]
+                        # Check that all expected clients were tested
+                        for client in clients_tested:
+                            assert client in actual_clients
+            else:
+                # Fallback to SQLAlchemy for verification
+                with engine.connect() as conn_sa:
+                    result = conn_sa.execute(text("SELECT COUNT(*) FROM multi_client"))
+                    expected_count = len(clients_tested)
+                    assert result.scalar() == expected_count