Clean up old versions of session cache tests

Author: fselmo

tests/core/providers/test_async_http_provider.py

@@ -8,9 +8,6 @@
     AsyncWeb3,
     __version__ as web3py_version,
 )
-from web3._utils import (
-    request,
-)
 from web3.eth import (
     AsyncEth,
 )
@@ -39,13 +36,6 @@
 URI = "http://mynode.local:8545"
 
 
-async def clean_async_session_cache():
-    cache_data = request._async_session_cache._data
-    while len(cache_data) > 0:
-        _key, cached_session = cache_data.popitem()
-        await cached_session.close()
-
-
 @pytest.mark.asyncio
 async def test_async_no_args() -> None:
     provider = AsyncHTTPProvider()
@@ -56,9 +46,6 @@ async def test_async_no_args() -> None:
     with pytest.raises(ProviderConnectionError):
         await w3.is_connected(show_traceback=True)
 
-    await clean_async_session_cache()
-    assert len(request._async_session_cache) == 0
-
 
 def test_init_kwargs():
     provider = AsyncHTTPProvider(endpoint_uri=URI, request_kwargs={"timeout": 60})
@@ -103,7 +90,7 @@ async def test_async_user_provided_session() -> None:
     session = ClientSession()
     provider = AsyncHTTPProvider(endpoint_uri=URI)
     cached_session = await provider.cache_async_session(session)
-    assert len(request._async_session_cache) == 1
+    assert len(provider._request_session_manager.session_cache) == 1
     assert cached_session == session
 
 

tests/core/providers/test_http_provider.py

@@ -11,9 +11,6 @@
     Web3,
     __version__ as web3py_version,
 )
-from web3._utils import (
-    request,
-)
 from web3.eth import (
     Eth,
 )
@@ -94,10 +91,10 @@ def test_user_provided_session():
     session.mount("https://", adapter)
 
     provider = HTTPProvider(endpoint_uri=URI, session=session)
+    session = provider._request_session_manager.cache_and_return_session(URI)
     w3 = Web3(provider)
     assert w3.manager.provider == provider
 
-    session = request.cache_and_return_session(URI)
     adapter = session.get_adapter(URI)
     assert isinstance(adapter, HTTPAdapter)
     assert adapter._pool_connections == 20

tests/core/providers/test_http_request_retry.py

@@ -52,7 +52,9 @@ def test_default_request_retry_configuration_for_http_provider():
 def test_check_without_retry_config():
     w3 = Web3(HTTPProvider(exception_retry_configuration=None))
 
-    with patch("web3.providers.rpc.rpc.make_post_request") as make_post_request_mock:
+    with patch(
+        "web3.providers.rpc.rpc.RequestSessionManager.make_post_request"
+    ) as make_post_request_mock:
         make_post_request_mock.side_effect = Timeout
 
         with pytest.raises(Timeout):
@@ -69,7 +71,10 @@ def test_check_if_retry_on_failure_true():
     assert check_if_retry_on_failure(method)
 
 
-@patch("web3.providers.rpc.rpc.make_post_request", side_effect=ConnectionError)
+@patch(
+    "web3.providers.rpc.rpc.RequestSessionManager.make_post_request",
+    side_effect=ConnectionError,
+)
 def test_check_send_transaction_called_once(make_post_request_mock, w3):
     with pytest.raises(ConnectionError):
         w3.provider.make_request(
@@ -78,7 +83,10 @@ def test_check_send_transaction_called_once(make_post_request_mock, w3):
     assert make_post_request_mock.call_count == 1
 
 
-@patch("web3.providers.rpc.rpc.make_post_request", side_effect=ConnectionError)
+@patch(
+    "web3.providers.rpc.rpc.RequestSessionManager.make_post_request",
+    side_effect=ConnectionError,
+)
 def test_valid_method_retried(make_post_request_mock, w3):
     with pytest.raises(ConnectionError):
         w3.provider.make_request(RPCEndpoint("eth_getBalance"), [f"0x{'00' * 20}"])
@@ -96,7 +104,10 @@ def test_exception_retry_config_is_strictly_on_http_provider():
     assert not hasattr(w3.provider, "exception_retry_configuration")
 
 
-@patch("web3.providers.rpc.rpc.make_post_request", side_effect=ConnectionError)
+@patch(
+    "web3.providers.rpc.rpc.RequestSessionManager.make_post_request",
+    side_effect=ConnectionError,
+)
 def test_exception_retry_middleware_with_allow_list_kwarg(make_post_request_mock):
     config = ExceptionRetryConfiguration(
         errors=(ConnectionError, HTTPError, Timeout, TooManyRedirects),
@@ -148,7 +159,7 @@ async def test_async_default_request_retry_configuration_for_http_provider():
 )
 async def test_async_check_retry_middleware(async_w3, error):
     with patch(
-        "web3.providers.rpc.async_rpc.async_make_post_request"
+        "web3.providers.rpc.async_rpc.RequestSessionManager.async_make_post_request"
     ) as async_make_post_request_mock:
         async_make_post_request_mock.side_effect = error
 
@@ -162,7 +173,7 @@ async def test_async_check_without_retry_config():
     w3 = AsyncWeb3(AsyncHTTPProvider(exception_retry_configuration=None))
 
     with patch(
-        "web3.providers.rpc.async_rpc.async_make_post_request"
+        "web3.providers.rpc.async_rpc.RequestSessionManager.async_make_post_request"
     ) as async_make_post_request_mock:
         async_make_post_request_mock.side_effect = TimeoutError
 
@@ -181,7 +192,7 @@ async def test_async_exception_retry_middleware_with_allow_list_kwarg():
     async_w3 = AsyncWeb3(AsyncHTTPProvider(exception_retry_configuration=config))
 
     with patch(
-        "web3.providers.rpc.async_rpc.async_make_post_request"
+        "web3.providers.rpc.async_rpc.RequestSessionManager.async_make_post_request"
     ) as async_make_post_request_mock:
         async_make_post_request_mock.side_effect = TimeoutError
 

tests/core/utilities/test_request.py

@@ -33,8 +33,6 @@
     SimpleCache,
 )
 
-request_session_manager = request.RequestSessionManager()
-
 
 class MockedResponse:
     def __init__(self, text="", status_code=200):
@@ -69,23 +67,20 @@ def check_adapters_mounted(session: Session):
     assert len(session.adapters) == 2
 
 
-def _simulate_call(uri):
+def _simulate_call(request_session_manager, uri):
     _session = request_session_manager.cache_and_return_session(uri)
 
     # simulate a call taking 0.01s to return a response
     time.sleep(0.01)
     return _session
 
 
-@pytest.fixture(autouse=True)
-def setup_and_teardown():
-    # clear session cache before and after each test
-    request_session_manager.session_cache.clear()
-    yield
-    request_session_manager.session_cache.clear()
+@pytest.fixture
+def request_session_manager():
+    return request.RequestSessionManager()
 
 
-def test_json_make_get_request(mocker):
+def test_session_manager_json_make_get_request(mocker, request_session_manager):
     mocker.patch("requests.Session.get", return_value=MockedResponse())
 
     # Submit a first request to create a session with default parameters
@@ -105,7 +100,7 @@ def test_json_make_get_request(mocker):
     assert adapter._pool_maxsize == DEFAULT_POOLSIZE
 
 
-def test_make_post_request_no_args(mocker):
+def test_session_manager_make_post_request_no_args(mocker, request_session_manager):
     mocker.patch("requests.Session.post", return_value=MockedResponse())
 
     # Submit a first request to create a session with default parameters
@@ -125,7 +120,7 @@ def test_make_post_request_no_args(mocker):
     assert adapter._pool_maxsize == DEFAULT_POOLSIZE
 
 
-def test_precached_session(mocker):
+def test_session_manager_precached_session(mocker, request_session_manager):
     mocker.patch("requests.Session.post", return_value=MockedResponse())
 
     # Update the cache with a handcrafted session
@@ -155,7 +150,7 @@ def test_precached_session(mocker):
     assert adapter._pool_maxsize == 100
 
 
-def test_cache_session_class():
+def test_simple_cache_cache_session():
     cache = SimpleCache(2)
     _, evicted_items = cache.cache("1", "Hello1")
     assert cache.get_cache_entry("1") == "Hello1"
@@ -183,7 +178,9 @@ def test_cache_session_class():
     assert cache.get_cache_entry("1") is None
 
 
-def test_cache_does_not_close_session_before_a_call_when_multithreading():
+def test_session_manager_cache_does_not_close_session_before_a_call_when_multithreading(
+    request_session_manager,
+):
     # save default values
     session_cache_default = request_session_manager.session_cache
     timeout_default = request.DEFAULT_TIMEOUT
@@ -194,7 +191,10 @@ def test_cache_does_not_close_session_before_a_call_when_multithreading():
     request.DEFAULT_TIMEOUT = _timeout_for_testing
 
     with ThreadPoolExecutor(max_workers=len(UNIQUE_URIS)) as exc:
-        all_sessions = [exc.submit(_simulate_call, uri) for uri in UNIQUE_URIS]
+        all_sessions = [
+            exc.submit(_simulate_call, request_session_manager, uri)
+            for uri in UNIQUE_URIS
+        ]
 
     # assert last session remains in cache, all others evicted
     cache_data = request_session_manager.session_cache._data
@@ -212,11 +212,16 @@ def test_cache_does_not_close_session_before_a_call_when_multithreading():
     request.DEFAULT_TIMEOUT = timeout_default
 
 
-def test_unique_cache_keys_created_per_thread_with_same_uri():
+def test_session_manager_unique_cache_keys_created_per_thread_with_same_uri(
+    request_session_manager,
+):
     # somewhat inspired by issue #2680
 
     with ThreadPoolExecutor(max_workers=2) as exc:
-        test_sessions = [exc.submit(_simulate_call, TEST_URI) for _ in range(2)]
+        test_sessions = [
+            exc.submit(_simulate_call, request_session_manager, TEST_URI)
+            for _ in range(2)
+        ]
 
     # assert unique keys are generated per thread for the same uri
     assert len(request_session_manager.session_cache._data) == 2
@@ -251,7 +256,9 @@ def raise_for_status() -> None:
 
 
 @pytest.mark.asyncio
-async def test_async_json_make_get_request(mocker):
+async def test_session_manager_async_json_make_get_request(
+    mocker, request_session_manager
+):
     mocker.patch("aiohttp.ClientSession.get", return_value=AsyncMockedResponse())
 
     # Submit a first request to create a session with default parameters
@@ -272,7 +279,7 @@ async def test_async_json_make_get_request(mocker):
 
 
 @pytest.mark.asyncio
-async def test_async_make_post_request(mocker):
+async def test_session_manager_async_make_post_request(mocker, request_session_manager):
     mocker.patch("aiohttp.ClientSession.post", return_value=AsyncMockedResponse())
 
     # Submit a first request to create a session with default parameters
@@ -296,7 +303,7 @@ async def test_async_make_post_request(mocker):
 
 
 @pytest.mark.asyncio
-async def test_async_precached_session():
+async def test_session_manager_async_precached_session(request_session_manager):
     # Add a session
     session = ClientSession()
     await request_session_manager.async_cache_and_return_session(TEST_URI, session)
@@ -322,7 +329,9 @@ async def test_async_precached_session():
 
 
 @pytest.mark.asyncio
-async def test_async_cache_does_not_close_session_before_a_call_when_multithreading():
+async def test_session_manager_async_cache_does_not_close_session_before_a_call_when_multithreading(  # noqa: E501
+    request_session_manager,
+):
     # save default values
     session_cache_default = request_session_manager.session_cache
     timeout_default = request.DEFAULT_TIMEOUT
@@ -368,7 +377,9 @@ async def cache_uri_and_return_session(uri):
 
 
 @pytest.mark.asyncio
-async def test_async_unique_cache_keys_created_per_thread_with_same_uri():
+async def test_session_manager_async_unique_cache_keys_created_per_thread_with_same_uri(
+    request_session_manager,
+):
     # inspired by issue #2680
     # Note: unique event loops for each thread are important here
 
@@ -407,7 +418,9 @@ def target_function(endpoint_uri):
 
 
 @pytest.mark.asyncio
-async def test_async_use_new_session_if_loop_closed_for_cached_session():
+async def test_session_manager_async_use_new_session_if_loop_closed_for_cached_session(
+    request_session_manager,
+):
     # create new loop, cache a session wihin the loop, close the loop
     loop1 = asyncio.new_event_loop()
 
@@ -448,7 +461,9 @@ async def test_async_use_new_session_if_loop_closed_for_cached_session():
 
 
 @pytest.mark.asyncio
-async def test_async_use_new_session_if_session_closed_for_cached_session():
+async def test_session_manager_async_use_new_session_if_session_closed_for_cached_session(  # noqa: E501
+    request_session_manager,
+):
     # create a session, close it, and cache it at the cache key for TEST_URI
     session1 = ClientSession(raise_for_status=True)
     await session1.close()

web3/providers/rpc/async_rpc.py

@@ -55,9 +55,7 @@
 class AsyncHTTPProvider(AsyncJSONBaseProvider):
     logger = logging.getLogger("web3.providers.AsyncHTTPProvider")
     endpoint_uri = None
-
     _request_kwargs = None
-    _request_session_manager = RequestSessionManager()
 
     def __init__(
         self,
@@ -68,6 +66,8 @@ def __init__(
         ] = empty,
         **kwargs: Any,
     ) -> None:
+        self._request_session_manager = RequestSessionManager()
+
         if endpoint_uri is None:
             self.endpoint_uri = (
                 self._request_session_manager.get_default_http_endpoint()

web3/providers/rpc/rpc.py

@@ -58,9 +58,7 @@
 class HTTPProvider(JSONBaseProvider):
     logger = logging.getLogger("web3.providers.HTTPProvider")
     endpoint_uri = None
-
     _request_kwargs = None
-    _request_session_manager = RequestSessionManager()
 
     def __init__(
         self,
@@ -72,6 +70,8 @@ def __init__(
         ] = empty,
         **kwargs: Any,
     ) -> None:
+        self._request_session_manager = RequestSessionManager()
+
         if endpoint_uri is None:
             self.endpoint_uri = (
                 self._request_session_manager.get_default_http_endpoint()