updated test_connection method

Author: jeffreyaven

.github/workflows/test.yaml

@@ -92,7 +92,7 @@ jobs:
         env:
           GITHUB_ACTIONS: 'true'
         run: |
-            nohup /tmp/stackql -v --pgsrv.port=5444 srv &
+            nohup /tmp/stackql -v --pgsrv.port=5466 srv &
             sleep 5
             python3 run_server_tests.py
 
@@ -101,7 +101,7 @@ jobs:
         shell: pwsh
         run: |
           Start-Process -FilePath "C:\Temp\stackql.exe" `
-                        -ArgumentList "-v", "--pgsrv.port=5444", "srv"
+                        -ArgumentList "-v", "--pgsrv.port=5466", "srv"
           Start-Sleep -Seconds 5
 
       - name: Stop StackQL server (Linux/macOS)

pystackql/core/stackql.py

@@ -432,4 +432,29 @@ async def executeQueriesAsync(self, queries):
                 "or switch to local mode if you need to run multiple queries concurrently."
             )
 
-        return await self.async_executor.execute_queries(queries)
+        return await self.async_executor.execute_queries(queries)
+    
+    def test_connection(self):
+        """Tests if the server connection is working by executing a simple query.
+        
+        This method is only valid when server_mode=True.
+        
+        Returns:
+            bool: True if the connection is working, False otherwise.
+            
+        Raises:
+            ValueError: If called when not in server mode.
+        """
+        if not self.server_mode:
+            raise ValueError("The test_connectivity method is only available in server mode.")
+        
+        try:
+            result = self.server_connection.execute_query("SELECT 'test' as test_value")
+            return (isinstance(result, list) and 
+                    len(result) == 1 and 
+                    'test_value' in result[0] and 
+                    result[0]['test_value'] == 'test')
+        except Exception as e:
+            if self.debug:
+                print(f"Connection test failed: {str(e)}")
+            return False

start-stackql-server.sh

@@ -1,7 +1,7 @@
 # start server if not running
 echo "checking if server is running"
 if [ -z "$(ps | grep stackql)" ]; then
-    nohup ./stackql -v --pgsrv.port=5444 srv &
+    nohup ./stackql -v --pgsrv.port=5466 srv &
     sleep 5
 else
     echo "server is already running"

tests/README.md

@@ -52,7 +52,7 @@ Server tests are skipped by default because they require a running StackQL serve
 
 1. Start a StackQL server:
    ```bash
-   stackql srv --pgsrv.address 127.0.0.1 --pgsrv.port 5444
+   stackql srv --pgsrv.address 127.0.0.1 --pgsrv.port 5466
    ```
 
 2. Run the server tests:

tests/conftest.py

@@ -48,51 +48,6 @@ def setup_stackql():
     # Return the StackQL instance for use in tests
     return stackql
 
-# def stackql_process_running():
-#     try:
-#         if platform.system() == "Windows":
-#             # Use `tasklist` to look for stackql.exe with correct port in args (may not include args, so fallback is loose match)
-#             output = subprocess.check_output(['tasklist', '/FI', 'IMAGENAME eq stackql.exe'], text=True)
-#             return "stackql.exe" in output
-#         else:
-#             # Use `ps aux` to search for 'stackql' process with the correct port
-#             output = subprocess.check_output(['ps', 'aux'], text=True)
-#             return f"--pgsrv.port={SERVER_PORT}" in output and "stackql" in output
-#     except subprocess.CalledProcessError:
-#         return False
-
-def stackql_process_running():
-    try:
-        if platform.system() == "Windows":
-            output = subprocess.check_output(
-                ['tasklist', '/FI', 'IMAGENAME eq stackql.exe'], text=True
-            )
-            return "stackql.exe" in output
-        else:
-            # More reliable: use pgrep + full argument check
-            output = subprocess.check_output(
-                f"ps aux | grep '[s]tackql' | grep -- '--pgsrv.port={SERVER_PORT}'",
-                shell=True,
-                text=True
-            )
-            return bool(output.strip())
-    except subprocess.CalledProcessError:
-        return False
-
-@pytest.fixture(scope="session")
-def stackql_server():
-    """
-    Verifies that a StackQL server process is running with the expected port.
-    Does not attempt to start or stop the process.
-    """
-    print(f"\n🔍 Checking for running StackQL server process (port {SERVER_PORT})...")
-
-    if not stackql_process_running():
-        pytest.exit(f"❌ No running StackQL server process found for port {SERVER_PORT}", returncode=1)
-
-    print("✅ StackQL server process is running.")
-    yield
-
 @pytest.fixture
 def mock_interactive_shell():
     """Create a mock IPython shell for testing."""

tests/test_constants.py

@@ -14,7 +14,7 @@
 import pandas as pd
 
 # Server connection settings
-SERVER_PORT = 5444
+SERVER_PORT = 5466
 SERVER_ADDRESS = "127.0.0.1"
 
 # Expected properties and patterns for validation

tests/test_server.py

@@ -7,6 +7,7 @@
 """
 
 import re
+import os
 import pytest
 import pandas as pd
 from unittest.mock import patch
@@ -20,29 +21,80 @@
     pystackql_test_setup
 )
 
-@pytest.mark.usefixtures("stackql_server")
+# @pytest.mark.usefixtures("stackql_server")
 class TestServerMode:
     """Tests for PyStackQL server mode functionality."""
 
     StackQL = StackQL  # For use with pystackql_test_setup decorator
-    
+    server_available = False  # Class-level flag to track server availability    
+
+    # @pystackql_test_setup(server_mode=True)
+    # def test_server_mode_connectivity(self):
+    #     """Test that server mode connects successfully."""
+    #     # Check server_mode flag is set correctly
+    #     assert self.stackql.server_mode, "StackQL should be in server mode"
+        
+    #     # Check server connection object exists
+    #     assert hasattr(self.stackql, 'server_connection'), "StackQL should have a server_connection attribute"
+    #     assert self.stackql.server_connection is not None, "Server connection object should not be None"
+        
+    #     # IMPORTANT: Actually test the connection works
+    #     connection_working = self.stackql.test_connection()
+        
+    #     # Print detailed results for debugging
+    #     if not connection_working:
+    #         print("⚠️ Server connection test failed: unable to execute a simple query")
+    #         print(f"Server address: {self.stackql.server_address}")
+    #         print(f"Server port: {self.stackql.server_port}")
+    #         print("\n❌ SERVER CONNECTION FAILED - SKIPPING REMAINING SERVER TESTS")
+    #     else:
+    #         # Set flag indicating server is available
+    #         TestServerMode.server_available = True
+        
+    #     print_test_result("Server mode connectivity test", 
+    #                     self.stackql.server_mode and 
+    #                     hasattr(self.stackql, 'server_connection') and 
+    #                     self.stackql.server_connection is not None and
+    #                     connection_working,  # Include connection check in the pass criteria
+    #                     True)
+        
+    #     # Add additional output about the actual connection status
+    #     print(f"  - Connection status: {'✅ WORKING' if connection_working else '❌ NOT WORKING'}")
+    #     print(f"  - Expected status: ✅ WORKING")  # Always expected to be working
+        
+    #     # Always assert that the connection is working
+    #     assert connection_working, "Server connection should be working"
+
     @pystackql_test_setup(server_mode=True)
     def test_server_mode_connectivity(self):
         """Test that server mode connects successfully."""
-        assert self.stackql.server_mode, "StackQL should be in server mode"
-        # Updated assertion to check server_connection attribute instead of _conn
-        assert hasattr(self.stackql, 'server_connection'), "StackQL should have a server_connection attribute"
-        assert self.stackql.server_connection is not None, "Server connection object should not be None"
-        
-        print_test_result("Server mode connectivity test", 
-                          self.stackql.server_mode and 
-                          hasattr(self.stackql, 'server_connection') and 
-                          self.stackql.server_connection is not None, 
-                          True)
-    
+        # Initialize class variable 
+        TestServerMode.server_available = False
+        
+        # Perform basic server connection test
+        connection_working = self.stackql.test_connection()
+        
+        if not connection_working:
+            # Log minimal diagnostic info
+            print("\n⚠️ Server connection failed")
+            print(f"Address: {self.stackql.server_address}:{self.stackql.server_port}")
+            print("❌ Skipping remaining server tests")
+            
+            # Fail with a concise message - this will be what shows in the error summary
+            pytest.fail("Server connection failed - please start stackql server")
+        
+        # Connection succeeded
+        TestServerMode.server_available = True
+        print("✅ Server connection successful")
+
     @pystackql_test_setup(server_mode=True)
     def test_server_mode_execute_stmt(self):
         """Test executeStmt in server mode."""
+
+        # Skip if server is not available
+        if not TestServerMode.server_available:
+            pytest.skip("Server is not available, skipping test")
+
         result = self.stackql.executeStmt(REGISTRY_PULL_HOMEBREW_QUERY)
 
         # Check result structure
@@ -60,6 +112,11 @@ def test_server_mode_execute_stmt(self):
     @pystackql_test_setup(server_mode=True, output='pandas')
     def test_server_mode_execute_stmt_pandas(self):
         """Test executeStmt in server mode with pandas output."""
+
+        # Skip if server is not available
+        if not TestServerMode.server_available:
+            pytest.skip("Server is not available, skipping test")
+
         result = self.stackql.executeStmt(REGISTRY_PULL_HOMEBREW_QUERY)
 
         # Check result structure
@@ -77,6 +134,11 @@ def test_server_mode_execute_stmt_pandas(self):
     @pystackql_test_setup(server_mode=True)
     def test_server_mode_execute(self):
         """Test execute in server mode."""
+
+        # Skip if server is not available
+        if not TestServerMode.server_available:
+            pytest.skip("Server is not available, skipping test")
+
         result = self.stackql.execute(LITERAL_INT_QUERY)
 
         # Check result structure
@@ -98,6 +160,11 @@ def test_server_mode_execute(self):
     @pystackql_test_setup(server_mode=True, output='pandas')
     def test_server_mode_execute_pandas(self):
         """Test execute in server mode with pandas output."""
+
+        # Skip if server is not available
+        if not TestServerMode.server_available:
+            pytest.skip("Server is not available, skipping test")
+
         result = self.stackql.execute(LITERAL_STRING_QUERY)
 
         # Check result structure
@@ -115,6 +182,11 @@ def test_server_mode_execute_pandas(self):
     @pystackql_test_setup(server_mode=True)
     def test_server_mode_provider_query(self):
         """Test querying a provider in server mode."""
+
+        # Skip if server is not available
+        if not TestServerMode.server_available:
+            pytest.skip("Server is not available, skipping test")
+
         result = self.stackql.execute(HOMEBREW_FORMULA_QUERY)
 
         # Check result structure
@@ -135,6 +207,11 @@ def test_server_mode_provider_query(self):
     @patch('pystackql.core.server.ServerConnection.execute_query')
     def test_server_mode_execute_mocked(self, mock_execute_query):
         """Test execute in server mode with mocked server response."""
+
+        # Skip if server is not available
+        if not TestServerMode.server_available:
+            pytest.skip("Server is not available, skipping test")
+
         # Create a StackQL instance in server mode
         stackql = StackQL(server_mode=True)
 
@@ -158,6 +235,11 @@ def test_server_mode_execute_mocked(self, mock_execute_query):
     @patch('pystackql.core.server.ServerConnection.execute_query')
     def test_server_mode_execute_pandas_mocked(self, mock_execute_query):
         """Test execute in server mode with pandas output and mocked server response."""
+
+        # Skip if server is not available
+        if not TestServerMode.server_available:
+            pytest.skip("Server is not available, skipping test")
+
         # Create a StackQL instance in server mode with pandas output
         stackql = StackQL(server_mode=True, output='pandas')
 
@@ -186,6 +268,11 @@ def test_server_mode_execute_pandas_mocked(self, mock_execute_query):
     @patch('pystackql.core.server.ServerConnection.execute_query')
     def test_server_mode_execute_stmt_mocked(self, mock_execute_query):
         """Test executeStmt in server mode with mocked server response."""
+
+        # Skip if server is not available
+        if not TestServerMode.server_available:
+            pytest.skip("Server is not available, skipping test")
+
         # Create a StackQL instance in server mode
         stackql = StackQL(server_mode=True)
 
@@ -208,6 +295,11 @@ def test_server_mode_execute_stmt_mocked(self, mock_execute_query):
 
     def test_server_mode_csv_output_error(self):
         """Test that server mode with csv output raises an error."""
+
+        # Skip if server is not available
+        if not TestServerMode.server_available:
+            pytest.skip("Server is not available, skipping test")
+
         with pytest.raises(ValueError) as exc_info:
             StackQL(server_mode=True, output='csv')