databricks
diff --git a/‎examples/experimental/sea_connector_test.py
Lines changed: 111 additions & 56 deletions b/‎examples/experimental/sea_connector_test.py
Lines changed: 111 additions & 56 deletions
diff --git a/‎examples/experimental/tests/__init__.py b/‎examples/experimental/tests/__init__.py
diff --git a/‎examples/experimental/tests/test_sea_async_query.py
Lines changed: 191 additions & 0 deletions b/‎examples/experimental/tests/test_sea_async_query.py
Lines changed: 191 additions & 0 deletions
@@ -1,66 +1,121 @@
+"""
+Main script to run all SEA connector tests.
+
+This script runs all the individual test modules and displays
+a summary of test results with visual indicators.
+
+In order to run the script, the following environment variables need to be set:
+- DATABRICKS_SERVER_HOSTNAME: The hostname of the Databricks server
+- DATABRICKS_HTTP_PATH: The HTTP path of the Databricks server
+- DATABRICKS_TOKEN: The token to use for authentication
+"""
+
 import os
 import sys
 import logging
-from databricks.sql.client import Connection
+import subprocess
+from typing import List, Tuple
 
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
-def test_sea_session():
-    """
-    Test opening and closing a SEA session using the connector.
-    
-    This function connects to a Databricks SQL endpoint using the SEA backend,
-    opens a session, and then closes it.
-    
-    Required environment variables:
-    - DATABRICKS_SERVER_HOSTNAME: Databricks server hostname
-    - DATABRICKS_HTTP_PATH: HTTP path for the SQL endpoint
-    - DATABRICKS_TOKEN: Personal access token for authentication
-    """
-
-    server_hostname = os.environ.get("DATABRICKS_SERVER_HOSTNAME")
-    http_path = os.environ.get("DATABRICKS_HTTP_PATH")
-    access_token = os.environ.get("DATABRICKS_TOKEN")
-    catalog = os.environ.get("DATABRICKS_CATALOG")
-    
-    if not all([server_hostname, http_path, access_token]):
-        logger.error("Missing required environment variables.")
-        logger.error("Please set DATABRICKS_SERVER_HOSTNAME, DATABRICKS_HTTP_PATH, and DATABRICKS_TOKEN.")
-        sys.exit(1)
-    
-    logger.info(f"Connecting to {server_hostname}")
-    logger.info(f"HTTP Path: {http_path}")
-    if catalog:
-        logger.info(f"Using catalog: {catalog}")
-    
-    try:
-        logger.info("Creating connection with SEA backend...")
-        connection = Connection(
-            server_hostname=server_hostname,
-            http_path=http_path,
-            access_token=access_token,
-            catalog=catalog,
-            schema="default",
-            use_sea=True, 
-            user_agent_entry="SEA-Test-Client" # add custom user agent
+TEST_MODULES = [
+    "test_sea_session",
+    "test_sea_sync_query",
+    "test_sea_async_query",
+    "test_sea_metadata",
+]
+
+
+def run_test_module(module_name: str) -> bool:
+    """Run a test module and return success status."""
+    module_path = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), "tests", f"{module_name}.py"
+    )
+
+    # Simply run the module as a script - each module handles its own test execution
+    result = subprocess.run(
+        [sys.executable, module_path], capture_output=True, text=True
+    )
+
+    # Log the output from the test module
+    if result.stdout:
+        for line in result.stdout.strip().split("\n"):
+            logger.info(line)
+
+    if result.stderr:
+        for line in result.stderr.strip().split("\n"):
+            logger.error(line)
+
+    return result.returncode == 0
+
+
+def run_tests() -> List[Tuple[str, bool]]:
+    """Run all tests and return results."""
+    results = []
+
+    for module_name in TEST_MODULES:
+        try:
+            logger.info(f"\n{'=' * 50}")
+            logger.info(f"Running test: {module_name}")
+            logger.info(f"{'-' * 50}")
+
+            success = run_test_module(module_name)
+            results.append((module_name, success))
+
+            status = "✅ PASSED" if success else "❌ FAILED"
+            logger.info(f"Test {module_name}: {status}")
+
+        except Exception as e:
+            logger.error(f"Error loading or running test {module_name}: {str(e)}")
+            import traceback
+
+            logger.error(traceback.format_exc())
+            results.append((module_name, False))
+
+    return results
+
+
+def print_summary(results: List[Tuple[str, bool]]) -> None:
+    """Print a summary of test results."""
+    logger.info(f"\n{'=' * 50}")
+    logger.info("TEST SUMMARY")
+    logger.info(f"{'-' * 50}")
+
+    passed = sum(1 for _, success in results if success)
+    total = len(results)
+
+    for module_name, success in results:
+        status = "✅ PASSED" if success else "❌ FAILED"
+        logger.info(f"{status} - {module_name}")
+
+    logger.info(f"{'-' * 50}")
+    logger.info(f"Total: {total} | Passed: {passed} | Failed: {total - passed}")
+    logger.info(f"{'=' * 50}")
+
+
+if __name__ == "__main__":
+    # Check if required environment variables are set
+    required_vars = [
+        "DATABRICKS_SERVER_HOSTNAME",
+        "DATABRICKS_HTTP_PATH",
+        "DATABRICKS_TOKEN",
+    ]
+    missing_vars = [var for var in required_vars if not os.environ.get(var)]
+
+    if missing_vars:
+        logger.error(
+            f"Missing required environment variables: {', '.join(missing_vars)}"
         )
-        
-        logger.info(f"Successfully opened SEA session with ID: {connection.get_session_id_hex()}")
-        logger.info(f"backend type: {type(connection.session.backend)}")
-        
-        # Close the connection
-        logger.info("Closing the SEA session...")
-        connection.close()
-        logger.info("Successfully closed SEA session")
-        
-    except Exception as e:
-        logger.error(f"Error testing SEA session: {str(e)}")
-        import traceback
-        logger.error(traceback.format_exc())
+        logger.error("Please set these variables before running the tests.")
         sys.exit(1)
-    
-    logger.info("SEA session test completed successfully")
 
-if __name__ == "__main__":
-    test_sea_session()
+    # Run all tests
+    results = run_tests()
+
+    # Print summary
+    print_summary(results)
+
+    # Exit with appropriate status code
+    all_passed = all(success for _, success in results)
+    sys.exit(0 if all_passed else 1)
@@ -0,0 +1,191 @@
+"""
+Test for SEA asynchronous query execution functionality.
+"""
+import os
+import sys
+import logging
+import time
+from databricks.sql.client import Connection
+from databricks.sql.backend.types import CommandState
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def test_sea_async_query_with_cloud_fetch():
+    """
+    Test executing a query asynchronously using the SEA backend with cloud fetch enabled.
+
+    This function connects to a Databricks SQL endpoint using the SEA backend,
+    executes a simple query asynchronously with cloud fetch enabled, and verifies that execution completes successfully.
+    """
+    server_hostname = os.environ.get("DATABRICKS_SERVER_HOSTNAME")
+    http_path = os.environ.get("DATABRICKS_HTTP_PATH")
+    access_token = os.environ.get("DATABRICKS_TOKEN")
+    catalog = os.environ.get("DATABRICKS_CATALOG")
+
+    if not all([server_hostname, http_path, access_token]):
+        logger.error("Missing required environment variables.")
+        logger.error(
+            "Please set DATABRICKS_SERVER_HOSTNAME, DATABRICKS_HTTP_PATH, and DATABRICKS_TOKEN."
+        )
+        return False
+
+    try:
+        # Create connection with cloud fetch enabled
+        logger.info(
+            "Creating connection for asynchronous query execution with cloud fetch enabled"
+        )
+        connection = Connection(
+            server_hostname=server_hostname,
+            http_path=http_path,
+            access_token=access_token,
+            catalog=catalog,
+            schema="default",
+            use_sea=True,
+            user_agent_entry="SEA-Test-Client",
+            use_cloud_fetch=True,
+        )
+
+        logger.info(
+            f"Successfully opened SEA session with ID: {connection.get_session_id_hex()}"
+        )
+
+        # Execute a simple query asynchronously
+        cursor = connection.cursor()
+        logger.info(
+            "Executing asynchronous query with cloud fetch: SELECT 1 as test_value"
+        )
+        cursor.execute_async("SELECT 1 as test_value")
+        logger.info(
+            "Asynchronous query submitted successfully with cloud fetch enabled"
+        )
+
+        # Check query state
+        logger.info("Checking query state...")
+        while cursor.is_query_pending():
+            logger.info("Query is still pending, waiting...")
+            time.sleep(1)
+
+        logger.info("Query is no longer pending, getting results...")
+        cursor.get_async_execution_result()
+        logger.info(
+            "Successfully retrieved asynchronous query results with cloud fetch enabled"
+        )
+
+        # Close resources
+        cursor.close()
+        connection.close()
+        logger.info("Successfully closed SEA session")
+
+        return True
+
+    except Exception as e:
+        logger.error(
+            f"Error during SEA asynchronous query execution test with cloud fetch: {str(e)}"
+        )
+        import traceback
+
+        logger.error(traceback.format_exc())
+        return False
+
+
+def test_sea_async_query_without_cloud_fetch():
+    """
+    Test executing a query asynchronously using the SEA backend with cloud fetch disabled.
+
+    This function connects to a Databricks SQL endpoint using the SEA backend,
+    executes a simple query asynchronously with cloud fetch disabled, and verifies that execution completes successfully.
+    """
+    server_hostname = os.environ.get("DATABRICKS_SERVER_HOSTNAME")
+    http_path = os.environ.get("DATABRICKS_HTTP_PATH")
+    access_token = os.environ.get("DATABRICKS_TOKEN")
+    catalog = os.environ.get("DATABRICKS_CATALOG")
+
+    if not all([server_hostname, http_path, access_token]):
+        logger.error("Missing required environment variables.")
+        logger.error(
+            "Please set DATABRICKS_SERVER_HOSTNAME, DATABRICKS_HTTP_PATH, and DATABRICKS_TOKEN."
+        )
+        return False
+
+    try:
+        # Create connection with cloud fetch disabled
+        logger.info(
+            "Creating connection for asynchronous query execution with cloud fetch disabled"
+        )
+        connection = Connection(
+            server_hostname=server_hostname,
+            http_path=http_path,
+            access_token=access_token,
+            catalog=catalog,
+            schema="default",
+            use_sea=True,
+            user_agent_entry="SEA-Test-Client",
+            use_cloud_fetch=False,
+            enable_query_result_lz4_compression=False,
+        )
+
+        logger.info(
+            f"Successfully opened SEA session with ID: {connection.get_session_id_hex()}"
+        )
+
+        # Execute a simple query asynchronously
+        cursor = connection.cursor()
+        logger.info(
+            "Executing asynchronous query without cloud fetch: SELECT 1 as test_value"
+        )
+        cursor.execute_async("SELECT 1 as test_value")
+        logger.info(
+            "Asynchronous query submitted successfully with cloud fetch disabled"
+        )
+
+        # Check query state
+        logger.info("Checking query state...")
+        while cursor.is_query_pending():
+            logger.info("Query is still pending, waiting...")
+            time.sleep(1)
+
+        logger.info("Query is no longer pending, getting results...")
+        cursor.get_async_execution_result()
+        logger.info(
+            "Successfully retrieved asynchronous query results with cloud fetch disabled"
+        )
+
+        # Close resources
+        cursor.close()
+        connection.close()
+        logger.info("Successfully closed SEA session")
+
+        return True
+
+    except Exception as e:
+        logger.error(
+            f"Error during SEA asynchronous query execution test without cloud fetch: {str(e)}"
+        )
+        import traceback
+
+        logger.error(traceback.format_exc())
+        return False
+
+
+def test_sea_async_query_exec():
+    """
+    Run both asynchronous query tests and return overall success.
+    """
+    with_cloud_fetch_success = test_sea_async_query_with_cloud_fetch()
+    logger.info(
+        f"Asynchronous query with cloud fetch: {'✅ PASSED' if with_cloud_fetch_success else '❌ FAILED'}"
+    )
+
+    without_cloud_fetch_success = test_sea_async_query_without_cloud_fetch()
+    logger.info(
+        f"Asynchronous query without cloud fetch: {'✅ PASSED' if without_cloud_fetch_success else '❌ FAILED'}"
+    )
+
+    return with_cloud_fetch_success and without_cloud_fetch_success
+
+
+if __name__ == "__main__":
+    success = test_sea_async_query_exec()
+    sys.exit(0 if success else 1)