made case sensitive check in url utils

Signed-off-by: Nikhil Suri <[email protected]>

Author: nikhilsuri-db

src/databricks/sql/common/url_utils.py

@@ -20,12 +20,25 @@ def normalize_host_with_protocol(host: str) -> str:
     Examples:
         normalize_host_with_protocol("myserver.com") -> "https://myserver.com"
         normalize_host_with_protocol("https://myserver.com") -> "https://myserver.com"
+        normalize_host_with_protocol("HTTPS://myserver.com") -> "https://myserver.com"
+    
+    Raises:
+        ValueError: If host is None or empty string
     """
+    # Handle None or empty host
+    if not host or not host.strip():
+        raise ValueError("Host cannot be None or empty")
+    
     # Remove trailing slash
     host = host.rstrip("/")
 
-    # Add protocol if not present
-    if not host.startswith("https://") and not host.startswith("http://"):
+    # Add protocol if not present (case-insensitive check)
+    host_lower = host.lower()
+    if not host_lower.startswith("https://") and not host_lower.startswith("http://"):
         host = f"https://{host}"
+    elif host_lower.startswith("https://") or host_lower.startswith("http://"):
+        # Normalize protocol to lowercase
+        protocol_end = host.index("://") + 3
+        host = host[:protocol_end].lower() + host[protocol_end:]
 
     return host

tests/e2e/test_circuit_breaker.py

@@ -23,6 +23,46 @@
 from databricks.sql.telemetry.circuit_breaker_manager import CircuitBreakerManager
 
 
+def wait_for_circuit_state(circuit_breaker, expected_state, timeout=5):
+    """
+    Wait for circuit breaker to reach expected state with polling.
+    
+    Args:
+        circuit_breaker: The circuit breaker instance to monitor
+        expected_state: The expected state (STATE_OPEN, STATE_CLOSED, STATE_HALF_OPEN)
+        timeout: Maximum time to wait in seconds
+        
+    Returns:
+        True if state reached, False if timeout
+    """
+    start = time.time()
+    while time.time() - start < timeout:
+        if circuit_breaker.current_state == expected_state:
+            return True
+        time.sleep(0.1)  # Poll every 100ms
+    return False
+
+
+def wait_for_circuit_state_multiple(circuit_breaker, expected_states, timeout=5):
+    """
+    Wait for circuit breaker to reach one of multiple expected states.
+    
+    Args:
+        circuit_breaker: The circuit breaker instance to monitor
+        expected_states: List of acceptable states
+        timeout: Maximum time to wait in seconds
+        
+    Returns:
+        True if any state reached, False if timeout
+    """
+    start = time.time()
+    while time.time() - start < timeout:
+        if circuit_breaker.current_state in expected_states:
+            return True
+        time.sleep(0.1)
+    return False
+
+
 @pytest.fixture(autouse=True)
 def aggressive_circuit_breaker_config():
     """
@@ -107,9 +147,13 @@ def mock_request(*args, **kwargs):
                     time.sleep(0.5)
 
                 if should_trigger:
-                    # Circuit should be OPEN after 2 rate-limit failures
+                    # Wait for circuit to open (async telemetry may take time)
+                    assert wait_for_circuit_state(circuit_breaker, STATE_OPEN, timeout=5), \
+                        f"Circuit didn't open within 5s, state: {circuit_breaker.current_state}"
+                    
+                    # Circuit should be OPEN after rate-limit failures
                     assert circuit_breaker.current_state == STATE_OPEN
-                    assert circuit_breaker.fail_counter == 2
+                    assert circuit_breaker.fail_counter >= 2  # At least 2 failures
 
                     # Track requests before another query
                     requests_before = request_count["count"]
@@ -197,7 +241,9 @@ def mock_conditional_request(*args, **kwargs):
                 cursor.fetchone()
                 time.sleep(2)
 
-                assert circuit_breaker.current_state == STATE_OPEN
+                # Wait for circuit to open
+                assert wait_for_circuit_state(circuit_breaker, STATE_OPEN, timeout=5), \
+                    f"Circuit didn't open, state: {circuit_breaker.current_state}"
 
                 # Wait for reset timeout (5 seconds in test)
                 time.sleep(6)
@@ -208,24 +254,20 @@ def mock_conditional_request(*args, **kwargs):
                 # Execute query to trigger HALF_OPEN state
                 cursor.execute("SELECT 3")
                 cursor.fetchone()
-                time.sleep(1)
 
-                # Circuit should be recovering
-                assert circuit_breaker.current_state in [
-                    STATE_HALF_OPEN,
-                    STATE_CLOSED,
-                ], f"Circuit should be recovering, but is {circuit_breaker.current_state}"
+                # Wait for circuit to start recovering
+                assert wait_for_circuit_state_multiple(
+                    circuit_breaker, [STATE_HALF_OPEN, STATE_CLOSED], timeout=5
+                ), f"Circuit didn't recover, state: {circuit_breaker.current_state}"
 
                 # Execute more queries to fully recover
                 cursor.execute("SELECT 4")
                 cursor.fetchone()
-                time.sleep(1)
 
-                current_state = circuit_breaker.current_state
-                assert current_state in [
-                    STATE_CLOSED,
-                    STATE_HALF_OPEN,
-                ], f"Circuit should recover to CLOSED or HALF_OPEN, got {current_state}"
+                # Wait for full recovery
+                assert wait_for_circuit_state_multiple(
+                    circuit_breaker, [STATE_CLOSED, STATE_HALF_OPEN], timeout=5
+                ), f"Circuit didn't fully recover, state: {circuit_breaker.current_state}"
 
 
 if __name__ == "__main__":

tests/unit/test_url_utils.py

@@ -28,9 +28,43 @@ class TestNormalizeHostWithProtocol:
         ("myserver.com/", "https://myserver.com"),
         ("https://myserver.com/", "https://myserver.com"),
         ("http://localhost/", "http://localhost"),
-    
+        
+        # Case-insensitive protocol handling - should normalize to lowercase
+        ("HTTPS://myserver.com", "https://myserver.com"),
+        ("HTTP://myserver.com", "http://myserver.com"),
+        ("HttPs://workspace.databricks.com", "https://workspace.databricks.com"),
+        ("HtTp://localhost:8080", "http://localhost:8080"),
+        ("HTTPS://MYSERVER.COM", "https://MYSERVER.COM"),  # Only protocol lowercased
+        
+        # Case-insensitive with trailing slashes
+        ("HTTPS://myserver.com/", "https://myserver.com"),
+        ("HTTP://localhost:8080/", "http://localhost:8080"),
+        ("HttPs://workspace.databricks.com//", "https://workspace.databricks.com"),
+        
+        # Mixed case protocols with ports
+        ("HTTPS://myserver.com:443", "https://myserver.com:443"),
+        ("HtTp://myserver.com:8080", "http://myserver.com:8080"),
+        
+        # Case preservation - only protocol lowercased, hostname case preserved
+        ("HTTPS://MyServer.DataBricks.COM", "https://MyServer.DataBricks.COM"),
+        ("HttPs://CamelCase.Server.com", "https://CamelCase.Server.com"),
+        ("HTTP://UPPERCASE.COM:8080", "http://UPPERCASE.COM:8080"),
     ])
     def test_normalize_host_with_protocol(self, input_host, expected_output):
         """Test host normalization with various input formats."""
-        assert normalize_host_with_protocol(input_host) == expected_output
+        result = normalize_host_with_protocol(input_host)
+        assert result == expected_output
+        
+        # Additional assertion: verify protocol is always lowercase
+        assert result.startswith("https://") or result.startswith("http://")
+
+    @pytest.mark.parametrize("invalid_host", [
+        None,
+        "",
+        "   ",  # Whitespace only
+    ])
+    def test_normalize_host_with_protocol_raises_on_invalid_input(self, invalid_host):
+        """Test that function raises ValueError for None or empty host."""
+        with pytest.raises(ValueError, match="Host cannot be None or empty"):
+            normalize_host_with_protocol(invalid_host)