SNOW-2865839: fixed no_proxy issues while performing PUT (#2684)

Co-authored-by: Przemek Denkiewicz <[email protected]>

Author: sfc-gh-fpawlowski

DESCRIPTION.md

@@ -10,6 +10,8 @@ Source code is also available at: https://github.com/snowflakedb/snowflake-conne
 - v4.1.1(TBD)
   - Relaxed pandas dependency requirements for Python below 3.12.
   - Changed CRL cache cleanup background task to daemon to avoid blocking main thread.
+  - Fixed NO_PROXY issues with PUT operations
+
 - v4.1.0(November 18,2025)
   - Added the `SNOWFLAKE_AUTH_FORCE_SERVER` environment variable to force the use of the local-listening server when using the `externalbrowser` auth method.
     - This allows headless environments (like Docker or Airflow) running locally to auth via a browser URL.

setup.cfg

@@ -85,6 +85,7 @@ boto =
 development =
     Cython
     coverage
+    mitmproxy>=6.0.0; python_version >= '3.10'
     more-itertools
     numpy<=2.2.4
     pendulum!=2.1.1

src/snowflake/connector/session_manager.py

@@ -483,26 +483,32 @@ def make_session(self, *, url: str | None = None) -> Session:
         self._mount_adapters(session)
         return session
 
+    @staticmethod
+    def _normalize_url(url: str | bytes | None) -> str:
+        """Normalize URL to string format (handles bytes from storage client)."""
+        return url.decode("utf-8") if isinstance(url, bytes) else url
+
     @contextlib.contextmanager
     @_propagate_session_manager_to_ocsp
     def use_session(
-        self, url: str | bytes, use_pooling: bool | None = None
+        self, url: str | bytes | None, use_pooling: bool | None = None
     ) -> Generator[Session, Any, None]:
+        """Yield a session for the given URL (used for proxy handling and pooling).
+        The 'url' is an obligatory parameter due to the need for correct proxy handling (i.e. bypassing caused by no_proxy settings).
         """
-        'url' is an obligatory parameter due to the need for correct proxy handling (i.e. bypassing caused by no_proxy settings).
-        """
+        url_str = self._normalize_url(url)
         use_pooling = use_pooling if use_pooling is not None else self.use_pooling
         if not use_pooling:
-            session = self.make_session(url=url)
+            session = self.make_session(url=url_str)
             try:
                 yield session
             finally:
                 session.close()
         else:
-            yield from self._yield_session_from_pool(url)
+            yield from self._yield_session_from_pool(url_str)
 
     def _yield_session_from_pool(
-        self, url: str | bytes
+        self, url: str | None
     ) -> Generator[SessionT, Any, None]:
         hostname = self._get_pooling_key_from_url(url)
         pool = self._sessions_map[hostname]
@@ -635,8 +641,8 @@ def get_manager(
         config: HttpConfig | None = None, **http_config_kwargs
     ) -> SessionManager:
         has_param_proxies = (
-            hasattr(config, "proxy_host") or "proxies" in http_config_kwargs
-        )
+            config and config.proxy_host is not None
+        ) or "proxies" in http_config_kwargs
         if has_param_proxies:
             return ProxySessionManager(config, **http_config_kwargs)
         else:

test/conftest.py

@@ -6,6 +6,7 @@
 from logging import getLogger
 from pathlib import Path
 from test.test_utils.cross_module_fixtures.http_fixtures import *  # NOQA
+from test.test_utils.cross_module_fixtures.mitm_fixtures import *  # NOQA
 from test.test_utils.cross_module_fixtures.wiremock_fixtures import *  # NOQA
 from typing import Generator
 

test/integ/test_proxies.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+"""Integration test for proxy with real Snowflake connection.
+
+Requirements:
+    mitmproxy is installed automatically via the [development] extras in setup.cfg
+    (Python 3.10+ only - mitmproxy has dependency conflicts on Python 3.9)
+
+Important:
+    When connecting through mitmproxy, you MUST set disable_ocsp_checks=True
+    because mitmproxy performs MITM with self-signed certificates that cannot
+    be validated via OCSP.
+"""
+from __future__ import annotations
+
+import sys
+
+import pytest
+
+from snowflake.connector.compat import IS_WINDOWS
+
+try:
+    from snowflake.connector.util_text import random_string
+except ImportError:
+    from ..randomize import random_string
+
+
+@pytest.mark.skipolddriver
+@pytest.mark.skipif(
+    sys.version_info < (3, 10),
+    reason="mitmproxy not installed for Python 3.9 due to dependency conflicts",
+)
+def test_put_with_https_proxy(conn_cnx, tmp_path, mitm_proxy, monkeypatch):
+    test_file = tmp_path / "test_data.csv"
+    test_file.write_text("col1,col2\n1,2\n3,4\n")
+
+    # Explicitly configure environment to use the proxy
+    mitm_proxy.set_env_vars(monkeypatch)
+
+    # Connect to REAL Snowflake through mitmproxy
+    # Must disable OCSP checks since mitmproxy presents self-signed certs for MITM
+    with conn_cnx(
+        disable_ocsp_checks=True,
+        login_timeout=60,  # Increase timeout for Windows proxy connection
+        network_timeout=60,  # Increase socket read timeout for proxy connections
+    ) as conn:
+        with conn.cursor() as cur:
+            stage_name = random_string(5, "test_proxy_")
+            cur.execute(f"CREATE TEMPORARY STAGE {stage_name}")
+
+            # Use str().replace() for cross-platform file URI compatibility (like other tests)
+            filename = str(test_file).replace("\\", "/")
+            put_result = cur.execute(
+                f"PUT 'file://{filename}' @{stage_name}"
+            ).fetchall()
+
+            assert len(put_result) > 0
+            assert put_result[0][6] == "UPLOADED"
+
+            ls_result = cur.execute(f"LIST @{stage_name}").fetchall()
+            assert len(ls_result) > 0
+
+
+@pytest.mark.skipolddriver
+@pytest.mark.skipif(
+    sys.version_info < (3, 10) or IS_WINDOWS,
+    reason="mitmproxy not installed for Python 3.9 due to dependency conflicts",
+)
+def test_put_with_https_proxy_and_no_proxy_regression(
+    conn_cnx, tmp_path, mitm_proxy, monkeypatch
+):
+    """SNOW-2865839: PUT fails with TypeError when HTTPS_PROXY and NO_PROXY are set.
+
+    From bug report:
+    "HTTPS_PROXY=http://localhost:8080 NO_PROXY='google.com' python test.py"
+    causes TypeError during PUT operations.
+
+    Bug flow:
+    1. HTTPS_PROXY set (mitmproxy)
+    2. NO_PROXY set with ANY value (e.g., "google.com")
+    3. Execute PUT operation
+    4. storage_client passes bytes URL to use_session()
+    5. Without fix: TypeError: inet_aton() argument 1 must be str, not bytes
+    6. With fix: PUT succeeds
+    """
+    test_file = tmp_path / "test_data.csv"
+    test_file.write_text("col1,col2\n1,2\n3,4\n")
+
+    # Configure environment to use mitmproxy
+    mitm_proxy.set_env_vars(monkeypatch)
+
+    # Set NO_PROXY with arbitrary value (from bug report)
+    monkeypatch.setenv("NO_PROXY", "google.com")
+
+    with conn_cnx(
+        disable_ocsp_checks=True,
+        login_timeout=60,  # Increase timeout for Windows proxy connection
+        network_timeout=60,  # Increase socket read timeout for proxy connections for Windows
+    ) as conn:
+        with conn.cursor() as cur:
+            stage_name = random_string(5, "test_no_proxy_")
+            cur.execute(f"CREATE TEMPORARY STAGE {stage_name}")
+
+            # This is where the bug occurs - storage_client passes bytes URL
+            # Use str().replace() for cross-platform file URI compatibility (like other tests)
+            filename = str(test_file).replace("\\", "/")
+            put_result = cur.execute(
+                f"PUT 'file://{filename}' @{stage_name}"
+            ).fetchall()
+
+            assert len(put_result) > 0
+            assert put_result[0][6] == "UPLOADED"
+
+            ls_result = cur.execute(f"LIST @{stage_name}").fetchall()
+            assert len(ls_result) > 0

test/test_utils/cross_module_fixtures/mitm_fixtures.py

@@ -0,0 +1,35 @@
+"""Mitmproxy fixtures for testing."""
+
+from typing import Any, Generator, Union
+
+import pytest
+
+from ..mitm import MitmClient
+
+
+@pytest.fixture(scope="session")
+def mitm_proxy() -> Generator[Union[MitmClient, Any], Any, None]:
+    """Start mitmproxy for transparent HTTPS proxying in tests.
+
+    This fixture (session-scoped):
+    - Starts mitmdump once for all tests
+    - Waits for CA certificate generation
+    - Returns MitmClient instance
+    - Cleans up after all tests complete
+
+    The fixture does NOT automatically configure proxy settings.
+    Tests should explicitly use the proxy via:
+    1. Environment variables: mitm_proxy.set_env_vars(monkeypatch)
+    2. Connection parameters: conn_cnx(proxy_host=mitm_proxy.host, ...)
+
+    Yields:
+        MitmClient: Running mitmproxy client instance
+
+    Fails:
+        When RuntimeError: If mitmproxy is not installed or fails to start
+    """
+    try:
+        with MitmClient() as client:
+            yield client
+    except (RuntimeError, TimeoutError) as e:
+        pytest.fail(f"Failed to start mitmproxy: {e}")

test/test_utils/mitm/__init__.py

@@ -0,0 +1,5 @@
+"""mitmproxy test utilities."""
+
+from .mitm_client import MitmClient
+
+__all__ = ["MitmClient"]