Remove _connect

Author: Tranquility2

modules/generic/testcontainers/generic/sql.py

@@ -21,11 +21,11 @@
 
 class ConnectWaitStrategy(WaitStrategy):
     """
-    Wait strategy that retries a container's _connect method until it succeeds or times out.
+    Wait strategy that tests database connectivity until it succeeds or times out.
 
-    This strategy assumes the container has a _connect method and will call it repeatedly
-    until it succeeds or the timeout is reached. It handles transient connection errors
-    and provides appropriate retry logic for database connectivity testing.
+    This strategy performs database connection testing using SQLAlchemy directly,
+    handling transient connection errors and providing appropriate retry logic
+    for database connectivity testing.
     """
 
     def __init__(self, transient_exceptions: Optional[tuple] = None):
@@ -34,33 +34,51 @@ def __init__(self, transient_exceptions: Optional[tuple] = None):
 
     def wait_until_ready(self, container: WaitStrategyTarget) -> None:
         """
-        Execute the container's _connect method with retry logic until it succeeds or times out.
+        Test database connectivity with retry logic until it succeeds or times out.
 
         Args:
-            container: The container that must have a _connect method
+            container: The SQL container that must have get_connection_url method
 
         Raises:
-            TimeoutError: If _connect fails after timeout
-            AttributeError: If container doesn't have _connect method
-            Exception: Any non-transient errors from _connect
+            TimeoutError: If connection fails after timeout
+            AttributeError: If container doesn't have get_connection_url method
+            ImportError: If SQLAlchemy is not installed
+            Exception: Any non-transient errors from connection attempts
         """
         import time
 
-        if not hasattr(container, "_connect"):
-            raise AttributeError(f"Container {container} must have a _connect method")
+        if not hasattr(container, "get_connection_url"):
+            raise AttributeError(f"Container {container} must have a get_connection_url method")
+
+        try:
+            import sqlalchemy
+        except ImportError as e:
+            logger.error("SQLAlchemy is required for database connectivity testing")
+            raise ImportError("SQLAlchemy is required for database containers") from e
 
         start_time = time.time()
 
         while True:
             if time.time() - start_time > self._startup_timeout:
                 raise TimeoutError(
-                    f"Container _connect failed after {self._startup_timeout}s timeout. "
+                    f"Database connection failed after {self._startup_timeout}s timeout. "
                     f"Hint: Check if the container is ready and the database is accessible."
                 )
 
             try:
-                container._connect()
-                return
+                connection_url = container.get_connection_url()
+                engine = sqlalchemy.create_engine(connection_url)
+
+                try:
+                    with engine.connect():
+                        logger.info("Database connection test successful")
+                        return
+                except Exception as e:
+                    logger.debug(f"Database connection attempt failed: {e}")
+                    raise
+                finally:
+                    engine.dispose()
+
             except self.transient_exceptions as e:
                 logger.debug(f"Connection attempt failed: {e}, retrying in {self._poll_interval}s...")
             except Exception as e:
@@ -79,35 +97,6 @@ class SqlContainer(DockerContainer):
     Database connection readiness is automatically handled by ConnectWaitStrategy.
     """
 
-    def _connect(self) -> None:
-        """
-        Test database connectivity using SQLAlchemy.
-
-        This method performs a single connection test without retry logic.
-        Retry logic is handled by the ConnectWaitStrategy.
-
-        Raises:
-            ImportError: If SQLAlchemy is not installed
-            Exception: If connection fails
-        """
-        try:
-            import sqlalchemy
-        except ImportError as e:
-            logger.error("SQLAlchemy is required for database connectivity testing")
-            raise ImportError("SQLAlchemy is required for database containers") from e
-
-        connection_url = self.get_connection_url()
-        engine = sqlalchemy.create_engine(connection_url)
-
-        try:
-            with engine.connect():
-                logger.info("Database connection test successful")
-        except Exception as e:
-            logger.debug(f"Database connection attempt failed: {e}")
-            raise
-        finally:
-            engine.dispose()
-
     def _create_connection_url(
         self,
         dialect: str,