"""Unit tests for urllib3 instrumentation deduplication logic."""

from unittest.mock import Mock, patch

import pytest

from drift.core.types import TuskDriftMode
from drift.instrumentation.urllib3.instrumentation import (
    Urllib3Instrumentation,
    _inside_poolmanager,
)


class TestContextVarInsidePoolManager:
    """Test the _inside_poolmanager ContextVar behavior."""

    def test_inside_poolmanager_default_value(self):
        """Test that _inside_poolmanager has a default value of False."""
        # ContextVar should have default value of False
        assert _inside_poolmanager.get() is False

    def test_inside_poolmanager_can_be_set(self):
        """Test that _inside_poolmanager can be set and retrieved."""
        # Set to True
        token = _inside_poolmanager.set(True)
        try:
            assert _inside_poolmanager.get() is True
        finally:
            _inside_poolmanager.reset(token)

        # Should be back to False after reset
        assert _inside_poolmanager.get() is False

    def test_inside_poolmanager_isolated_across_contexts(self):
        """Test that _inside_poolmanager is properly isolated across contexts."""
        # Set to True
        token = _inside_poolmanager.set(True)
        assert _inside_poolmanager.get() is True

        # Reset should restore to default
        _inside_poolmanager.reset(token)
        assert _inside_poolmanager.get() is False


class TestPatchedUrlopenPoolManager:
    """Test the patched_urlopen function for PoolManager."""

    @pytest.fixture
    def mock_sdk(self):
        """Create a mock TuskDrift SDK instance."""
        sdk = Mock()
        sdk.mode = TuskDriftMode.RECORD
        sdk.app_ready = True
        return sdk

    @pytest.fixture
    def instrumentation(self):
        """Create an instrumentation instance."""
        return Urllib3Instrumentation(enabled=True)

    @pytest.fixture
    def mock_urllib3_module(self):
        """Create a mock urllib3 module with PoolManager."""
        module = Mock()
        module.PoolManager = Mock()
        module.PoolManager.urlopen = Mock(return_value=Mock(status=200))
        return module

    def test_patched_urlopen_sets_inside_poolmanager_context(self, instrumentation, mock_urllib3_module, mock_sdk):
        """Test that patched PoolManager.urlopen sets _inside_poolmanager to True during execution."""
        original_urlopen = mock_urllib3_module.PoolManager.urlopen
        inside_poolmanager_values = []

        # Wrap original_urlopen to capture the context var value during execution
        def capture_context(*args, **kwargs):
            inside_poolmanager_values.append(_inside_poolmanager.get())
            return original_urlopen(*args, **kwargs)

        mock_urllib3_module.PoolManager.urlopen = capture_context

        # Apply the patch
        instrumentation._patch_pool_manager(mock_urllib3_module)

        # Get the patched function
        patched_fn = mock_urllib3_module.PoolManager.urlopen

        # Mock the SDK
        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            with patch.object(instrumentation, "_is_already_instrumented_by_higher_level", return_value=False):
                # Before calling, should be False
                assert _inside_poolmanager.get() is False

                try:
                    # Call the patched function (will raise because handle_record_mode is not fully mocked)
                    pool_self = Mock()
                    patched_fn(pool_self, "GET", "http://example.com")
                except Exception:
                    # Expected - we're not fully mocking the record mode handler
                    pass

                # During execution, it should have been True
                # (captured by our wrapper)
                if inside_poolmanager_values:
                    assert inside_poolmanager_values[0] is True

                # After calling, should be reset to False
                assert _inside_poolmanager.get() is False

    def test_patched_urlopen_resets_inside_poolmanager_on_exception(
        self, instrumentation, mock_urllib3_module, mock_sdk
    ):
        """Test that _inside_poolmanager is reset even if an exception occurs."""
        # Make the original function raise an exception
        mock_urllib3_module.PoolManager.urlopen = Mock(side_effect=RuntimeError("Test error"))

        # Apply the patch
        instrumentation._patch_pool_manager(mock_urllib3_module)
        patched_fn = mock_urllib3_module.PoolManager.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            with patch.object(instrumentation, "_is_already_instrumented_by_higher_level", return_value=False):
                pool_self = Mock()

                # Should be False before
                assert _inside_poolmanager.get() is False

                # Call should raise, but context should still be reset
                with pytest.raises(RuntimeError, match="Test error"):
                    patched_fn(pool_self, "GET", "http://example.com")

                # Should be False after exception
                assert _inside_poolmanager.get() is False

    def test_patched_urlopen_disabled_mode_does_not_set_context(self, instrumentation, mock_urllib3_module, mock_sdk):
        """Test that disabled mode doesn't set the context var (exits early)."""
        mock_sdk.mode = TuskDriftMode.DISABLED

        original_urlopen = Mock(return_value=Mock(status=200))
        mock_urllib3_module.PoolManager.urlopen = original_urlopen

        instrumentation._patch_pool_manager(mock_urllib3_module)
        patched_fn = mock_urllib3_module.PoolManager.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            pool_self = Mock()
            patched_fn(pool_self, "GET", "http://example.com")

            # Should have called original
            original_urlopen.assert_called_once()

            # Context var should still be False (wasn't set in disabled mode path)
            assert _inside_poolmanager.get() is False


class TestPatchedUrlopenConnectionPool:
    """Test the patched_urlopen function for HTTPConnectionPool."""

    @pytest.fixture
    def mock_sdk(self):
        """Create a mock TuskDrift SDK instance."""
        sdk = Mock()
        sdk.mode = TuskDriftMode.RECORD
        sdk.app_ready = True
        return sdk

    @pytest.fixture
    def instrumentation(self):
        """Create an instrumentation instance."""
        return Urllib3Instrumentation(enabled=True)

    @pytest.fixture
    def mock_urllib3_module(self):
        """Create a mock urllib3 module with HTTPConnectionPool."""
        module = Mock()
        module.HTTPConnectionPool = Mock()
        module.HTTPConnectionPool.urlopen = Mock(return_value=Mock(status=200))
        return module

    def test_patched_urlopen_skips_when_inside_poolmanager(self, instrumentation, mock_urllib3_module, mock_sdk):
        """Test that HTTPConnectionPool.urlopen skips span creation when _inside_poolmanager is True."""
        original_urlopen = Mock(return_value=Mock(status=200, headers={}, data=b""))
        mock_urllib3_module.HTTPConnectionPool.urlopen = original_urlopen

        # Apply the patch
        instrumentation._patch_connection_pool(mock_urllib3_module)
        patched_fn = mock_urllib3_module.HTTPConnectionPool.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            # Set the context var to simulate being called from PoolManager
            token = _inside_poolmanager.set(True)
            try:
                pool_self = Mock()
                pool_self.scheme = "https"
                pool_self.host = "example.com"
                pool_self.port = 443

                # Call should pass through without creating span
                result = patched_fn(pool_self, "GET", "/path")

                # Should have called the original function
                original_urlopen.assert_called_once()
                assert result is not None

            finally:
                _inside_poolmanager.reset(token)

    def test_patched_urlopen_creates_span_when_not_inside_poolmanager(
        self, instrumentation, mock_urllib3_module, mock_sdk
    ):
        """Test that HTTPConnectionPool.urlopen creates a span when _inside_poolmanager is False."""
        original_urlopen = Mock(return_value=Mock(status=200, headers={}, data=b""))
        mock_urllib3_module.HTTPConnectionPool.urlopen = original_urlopen

        # Apply the patch
        instrumentation._patch_connection_pool(mock_urllib3_module)
        patched_fn = mock_urllib3_module.HTTPConnectionPool.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            with patch.object(instrumentation, "_is_already_instrumented_by_higher_level", return_value=False):
                # Ensure _inside_poolmanager is False
                assert _inside_poolmanager.get() is False

                pool_self = Mock()
                pool_self.scheme = "https"
                pool_self.host = "example.com"
                pool_self.port = 443

                try:
                    # This will fail because we're not mocking the full record mode flow,
                    # but it should NOT short-circuit via the _inside_poolmanager check
                    patched_fn(pool_self, "GET", "/path")
                except Exception:
                    # Expected - we're testing that it doesn't take the passthrough path
                    pass

                # The key is that original_urlopen should NOT be called directly
                # (it would be called inside handle_record_mode which we didn't fully mock)

    def test_patched_urlopen_disabled_mode_returns_passthrough(self, instrumentation, mock_urllib3_module, mock_sdk):
        """Test that disabled mode uses _passthrough to skip instrumentation."""
        mock_sdk.mode = TuskDriftMode.DISABLED

        original_urlopen = Mock(return_value=Mock(status=200))
        mock_urllib3_module.HTTPConnectionPool.urlopen = original_urlopen

        instrumentation._patch_connection_pool(mock_urllib3_module)
        patched_fn = mock_urllib3_module.HTTPConnectionPool.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            pool_self = Mock()
            pool_self.scheme = "http"
            pool_self.host = "example.com"
            pool_self.port = 80

            result = patched_fn(pool_self, "POST", "/api", body=b"test")

            # Should have called original
            original_urlopen.assert_called_once()
            assert result.status == 200

    def test_patched_urlopen_higher_level_instrumentation_returns_passthrough(
        self, instrumentation, mock_urllib3_module, mock_sdk
    ):
        """Test that higher-level instrumentation causes passthrough."""
        original_urlopen = Mock(return_value=Mock(status=200))
        mock_urllib3_module.HTTPConnectionPool.urlopen = original_urlopen

        instrumentation._patch_connection_pool(mock_urllib3_module)
        patched_fn = mock_urllib3_module.HTTPConnectionPool.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            with patch.object(instrumentation, "_is_already_instrumented_by_higher_level", return_value=True):
                pool_self = Mock()
                pool_self.scheme = "http"
                pool_self.host = "example.com"
                pool_self.port = 80

                # Ensure not inside poolmanager
                assert _inside_poolmanager.get() is False

                result = patched_fn(pool_self, "GET", "/")

                # Should have called original via passthrough
                original_urlopen.assert_called_once()
                assert result.status == 200


class TestDeduplicationIntegration:
    """Integration tests for the deduplication logic."""

    @pytest.fixture
    def instrumentation(self):
        """Create an instrumentation instance."""
        return Urllib3Instrumentation(enabled=True)

    @pytest.fixture
    def mock_urllib3_module(self):
        """Create a mock urllib3 module with both PoolManager and HTTPConnectionPool."""
        module = Mock()

        # Mock PoolManager
        module.PoolManager = Mock()

        # Mock HTTPConnectionPool
        module.HTTPConnectionPool = Mock()

        return module

    def test_poolmanager_delegates_to_connection_pool_without_duplicate_span(
        self, instrumentation, mock_urllib3_module
    ):
        """Test that when PoolManager delegates to HTTPConnectionPool, only one span is created."""
        mock_sdk = Mock()
        mock_sdk.mode = TuskDriftMode.RECORD
        mock_sdk.app_ready = True

        span_creation_count = {"count": 0}

        # Track how many times span creation is attempted
        def mock_create_span(*args, **kwargs):
            span_creation_count["count"] += 1
            return None  # Return None to simulate span creation failure (simplifies test)

        # Create a mock that simulates PoolManager calling HTTPConnectionPool
        connection_pool_calls = []

        def mock_pool_manager_urlopen(pool_self, method, url, redirect=True, **kw):
            # This simulates PoolManager internally calling HTTPConnectionPool.urlopen
            connection_pool_instance = Mock()
            connection_pool_instance.scheme = "https"
            connection_pool_instance.host = "example.com"
            connection_pool_instance.port = 443

            # Call the patched connection pool urlopen
            result = mock_urllib3_module.HTTPConnectionPool.urlopen(connection_pool_instance, method, "/path")
            connection_pool_calls.append(True)
            return result

        mock_urllib3_module.PoolManager.urlopen = mock_pool_manager_urlopen

        # Set up HTTPConnectionPool to return a simple response
        original_connection_pool_urlopen = Mock(return_value=Mock(status=200, headers={}, data=b"test response"))
        mock_urllib3_module.HTTPConnectionPool.urlopen = original_connection_pool_urlopen

        # Apply both patches
        instrumentation._patch_pool_manager(mock_urllib3_module)
        instrumentation._patch_connection_pool(mock_urllib3_module)

        # Get the patched functions
        patched_pool_manager = mock_urllib3_module.PoolManager.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            with patch.object(instrumentation, "_is_already_instrumented_by_higher_level", return_value=False):
                with patch.object(instrumentation, "_create_client_span", side_effect=mock_create_span):
                    pool_self = Mock()

                    try:
                        # Call PoolManager.urlopen, which will internally call HTTPConnectionPool.urlopen
                        patched_pool_manager(pool_self, "GET", "http://example.com/path")
                    except Exception:
                        # May fail due to incomplete mocking, that's ok
                        pass

                    # The connection pool should have been called
                    assert len(connection_pool_calls) > 0

                    # But due to _inside_poolmanager context, the connection pool patch
                    # should have taken the passthrough route and NOT attempted span creation
                    # Only PoolManager should have attempted span creation
                    # So we expect span creation to be attempted only once (by PoolManager)
                    assert span_creation_count["count"] <= 1

    def test_inside_poolmanager_default_value(self):
        """Test that _inside_poolmanager has a default value of False."""
        # ContextVar should have default value of False
        assert _inside_poolmanager.get() is False

    def test_inside_poolmanager_can_be_set(self):
        """Test that _inside_poolmanager can be set and retrieved."""
        # Set to True
        token = _inside_poolmanager.set(True)
        try:
            assert _inside_poolmanager.get() is True
        finally:
            _inside_poolmanager.reset(token)

        # Should be back to False after reset
        assert _inside_poolmanager.get() is False

    def test_inside_poolmanager_isolated_across_contexts(self):
        """Test that _inside_poolmanager is properly isolated across contexts."""
        # Set to True
        token = _inside_poolmanager.set(True)
        assert _inside_poolmanager.get() is True

        # Reset should restore to default
        _inside_poolmanager.reset(token)
        assert _inside_poolmanager.get() is False

    def test_patched_urlopen_skips_when_inside_poolmanager(self, instrumentation, mock_urllib3_module, mock_sdk):
        """Test that HTTPConnectionPool.urlopen skips span creation when _inside_poolmanager is True."""
        original_urlopen = Mock(return_value=Mock(status=200, headers={}, data=b""))
        mock_urllib3_module.HTTPConnectionPool.urlopen = original_urlopen

        # Apply the patch
        instrumentation._patch_connection_pool(mock_urllib3_module)
        patched_fn = mock_urllib3_module.HTTPConnectionPool.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            # Set the context var to simulate being called from PoolManager
            token = _inside_poolmanager.set(True)
            try:
                pool_self = Mock()
                pool_self.scheme = "https"
                pool_self.host = "example.com"
                pool_self.port = 443

                # Call should pass through without creating span
                result = patched_fn(pool_self, "GET", "/path")

                # Should have called the original function
                original_urlopen.assert_called_once()
                assert result is not None

            finally:
                _inside_poolmanager.reset(token)

    def test_patched_urlopen_creates_span_when_not_inside_poolmanager(
        self, instrumentation, mock_urllib3_module, mock_sdk
    ):
        """Test that HTTPConnectionPool.urlopen creates a span when _inside_poolmanager is False."""
        original_urlopen = Mock(return_value=Mock(status=200, headers={}, data=b""))
        mock_urllib3_module.HTTPConnectionPool.urlopen = original_urlopen

        # Apply the patch
        instrumentation._patch_connection_pool(mock_urllib3_module)
        patched_fn = mock_urllib3_module.HTTPConnectionPool.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            with patch.object(instrumentation, "_is_already_instrumented_by_higher_level", return_value=False):
                # Ensure _inside_poolmanager is False
                assert _inside_poolmanager.get() is False

                pool_self = Mock()
                pool_self.scheme = "https"
                pool_self.host = "example.com"
                pool_self.port = 443

                try:
                    # This will fail because we're not mocking the full record mode flow,
                    # but it should NOT short-circuit via the _inside_poolmanager check
                    patched_fn(pool_self, "GET", "/path")
                except Exception:
                    # Expected - we're testing that it doesn't take the passthrough path
                    pass

                # The key is that original_urlopen should NOT be called directly
                # (it would be called inside handle_record_mode which we didn't fully mock)

    def test_patched_urlopen_disabled_mode_returns_passthrough(self, instrumentation, mock_urllib3_module, mock_sdk):
        """Test that disabled mode uses _passthrough to skip instrumentation."""
        mock_sdk.mode = TuskDriftMode.DISABLED

        original_urlopen = Mock(return_value=Mock(status=200))
        mock_urllib3_module.HTTPConnectionPool.urlopen = original_urlopen

        instrumentation._patch_connection_pool(mock_urllib3_module)
        patched_fn = mock_urllib3_module.HTTPConnectionPool.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            pool_self = Mock()
            pool_self.scheme = "http"
            pool_self.host = "example.com"
            pool_self.port = 80

            result = patched_fn(pool_self, "POST", "/api", body=b"test")

            # Should have called original
            original_urlopen.assert_called_once()
            assert result.status == 200

    def test_patched_urlopen_higher_level_instrumentation_returns_passthrough(
        self, instrumentation, mock_urllib3_module, mock_sdk
    ):
        """Test that higher-level instrumentation causes passthrough."""
        original_urlopen = Mock(return_value=Mock(status=200))
        mock_urllib3_module.HTTPConnectionPool.urlopen = original_urlopen

        instrumentation._patch_connection_pool(mock_urllib3_module)
        patched_fn = mock_urllib3_module.HTTPConnectionPool.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            with patch.object(instrumentation, "_is_already_instrumented_by_higher_level", return_value=True):
                pool_self = Mock()
                pool_self.scheme = "http"
                pool_self.host = "example.com"
                pool_self.port = 80

                # Ensure not inside poolmanager
                assert _inside_poolmanager.get() is False

                result = patched_fn(pool_self, "GET", "/")

                # Should have called original via passthrough
                original_urlopen.assert_called_once()
                assert result.status == 200

    def test_patched_urlopen_sets_inside_poolmanager_context(self, instrumentation, mock_urllib3_module, mock_sdk):
        """Test that patched PoolManager.urlopen sets _inside_poolmanager to True during execution."""
        original_urlopen = mock_urllib3_module.PoolManager.urlopen
        inside_poolmanager_values = []

        # Wrap original_urlopen to capture the context var value during execution
        def capture_context(*args, **kwargs):
            inside_poolmanager_values.append(_inside_poolmanager.get())
            return original_urlopen(*args, **kwargs)

        mock_urllib3_module.PoolManager.urlopen = capture_context

        # Apply the patch
        instrumentation._patch_pool_manager(mock_urllib3_module)

        # Get the patched function
        patched_fn = mock_urllib3_module.PoolManager.urlopen

        # Mock the SDK
        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            with patch.object(instrumentation, "_is_already_instrumented_by_higher_level", return_value=False):
                # Before calling, should be False
                assert _inside_poolmanager.get() is False

                try:
                    # Call the patched function (will raise because handle_record_mode is not fully mocked)
                    pool_self = Mock()
                    patched_fn(pool_self, "GET", "http://example.com")
                except Exception:
                    # Expected - we're not fully mocking the record mode handler
                    pass

                # During execution, it should have been True
                # (captured by our wrapper)
                if inside_poolmanager_values:
                    assert inside_poolmanager_values[0] is True

                # After calling, should be reset to False
                assert _inside_poolmanager.get() is False

    def test_patched_urlopen_resets_inside_poolmanager_on_exception(
        self, instrumentation, mock_urllib3_module, mock_sdk
    ):
        """Test that _inside_poolmanager is reset even if an exception occurs."""
        # Make the original function raise an exception
        mock_urllib3_module.PoolManager.urlopen = Mock(side_effect=RuntimeError("Test error"))

        # Apply the patch
        instrumentation._patch_pool_manager(mock_urllib3_module)
        patched_fn = mock_urllib3_module.PoolManager.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            with patch.object(instrumentation, "_is_already_instrumented_by_higher_level", return_value=False):
                pool_self = Mock()

                # Should be False before
                assert _inside_poolmanager.get() is False

                # Call should raise, but context should still be reset
                with pytest.raises(RuntimeError, match="Test error"):
                    patched_fn(pool_self, "GET", "http://example.com")

                # Should be False after exception
                assert _inside_poolmanager.get() is False

    def test_patched_urlopen_disabled_mode_does_not_set_context(self, instrumentation, mock_urllib3_module, mock_sdk):
        """Test that disabled mode doesn't set the context var (exits early)."""
        mock_sdk.mode = TuskDriftMode.DISABLED

        original_urlopen = Mock(return_value=Mock(status=200))
        mock_urllib3_module.PoolManager.urlopen = original_urlopen

        instrumentation._patch_pool_manager(mock_urllib3_module)
        patched_fn = mock_urllib3_module.PoolManager.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            pool_self = Mock()
            patched_fn(pool_self, "GET", "http://example.com")

            # Should have called original
            original_urlopen.assert_called_once()

            # Context var should still be False (wasn't set in disabled mode path)
            assert _inside_poolmanager.get() is False

    def test_poolmanager_delegates_to_connection_pool_without_duplicate_span(
        self, instrumentation, mock_urllib3_module
    ):
        """Test that when PoolManager delegates to HTTPConnectionPool, only one span is created."""
        mock_sdk = Mock()
        mock_sdk.mode = TuskDriftMode.RECORD
        mock_sdk.app_ready = True

        span_creation_count = {"count": 0}

        # Track how many times span creation is attempted
        def mock_create_span(*args, **kwargs):
            span_creation_count["count"] += 1
            return None  # Return None to simulate span creation failure (simplifies test)

        # Create a mock that simulates PoolManager calling HTTPConnectionPool
        connection_pool_calls = []

        def mock_pool_manager_urlopen(pool_self, method, url, redirect=True, **kw):
            # This simulates PoolManager internally calling HTTPConnectionPool.urlopen
            connection_pool_instance = Mock()
            connection_pool_instance.scheme = "https"
            connection_pool_instance.host = "example.com"
            connection_pool_instance.port = 443

            # Call the patched connection pool urlopen
            result = mock_urllib3_module.HTTPConnectionPool.urlopen(connection_pool_instance, method, "/path")
            connection_pool_calls.append(True)
            return result

        mock_urllib3_module.PoolManager.urlopen = mock_pool_manager_urlopen

        # Set up HTTPConnectionPool to return a simple response
        original_connection_pool_urlopen = Mock(return_value=Mock(status=200, headers={}, data=b"test response"))
        mock_urllib3_module.HTTPConnectionPool.urlopen = original_connection_pool_urlopen

        # Apply both patches
        instrumentation._patch_pool_manager(mock_urllib3_module)
        instrumentation._patch_connection_pool(mock_urllib3_module)

        # Get the patched functions
        patched_pool_manager = mock_urllib3_module.PoolManager.urlopen

        with patch("drift.instrumentation.urllib3.instrumentation.TuskDrift.get_instance", return_value=mock_sdk):
            with patch.object(instrumentation, "_is_already_instrumented_by_higher_level", return_value=False):
                with patch.object(instrumentation, "_create_client_span", side_effect=mock_create_span):
                    pool_self = Mock()

                    try:
                        # Call PoolManager.urlopen, which will internally call HTTPConnectionPool.urlopen
                        patched_pool_manager(pool_self, "GET", "http://example.com/path")
                    except Exception:
                        # May fail due to incomplete mocking, that's ok
                        pass

                    # The connection pool should have been called
                    assert len(connection_pool_calls) > 0

                    # But due to _inside_poolmanager context, the connection pool patch
                    # should have taken the passthrough route and NOT attempted span creation
                    # Only PoolManager should have attempted span creation
                    # So we expect span creation to be attempted only once (by PoolManager)
                    assert span_creation_count["count"] <= 1