web3 7.0.0b2__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/_utils/module_testing/go_ethereum_debug_module.py

@@ -0,0 +1,128 @@
+import pytest
+from typing import (
+    cast,
+)
+
+from eth_typing import (
+    HexStr,
+)
+
+from web3 import (
+    AsyncWeb3,
+    Web3,
+)
+from web3.types import (
+    BlockData,
+    CallTrace,
+    ChecksumAddress,
+    DiffModeTrace,
+    OpcodeTrace,
+    PrestateTrace,
+)
+
+
+class GoEthereumAsyncDebugModuleTest:
+    @pytest.mark.asyncio
+    async def test_async_geth_debug_trace_transaction_opcode_logger(
+        self, async_w3: "AsyncWeb3", txn_hash_with_log: HexStr
+    ) -> None:
+        result = await async_w3.geth.debug.trace_transaction(txn_hash_with_log)
+        assert "structLogs" in dict(result).keys()
+        assert "gas" in dict(result).keys()
+        assert "failed" in dict(result).keys()
+
+    @pytest.mark.asyncio
+    async def test_async_geth_debug_trace_transaction_call_tracer(
+        self, async_w3: "AsyncWeb3", txn_hash_with_log: HexStr
+    ) -> None:
+        result = cast(
+            CallTrace,
+            await async_w3.geth.debug.trace_transaction(
+                txn_hash_with_log, {"tracer": "callTracer"}
+            ),
+        )
+        assert result.get("type") == "CALL"
+
+    @pytest.mark.asyncio
+    async def test_async_geth_debug_trace_transaction_prestate_tracer_diffMode(
+        self, async_w3: "AsyncWeb3", txn_hash_with_log: HexStr
+    ) -> None:
+        result = cast(
+            DiffModeTrace,
+            await async_w3.geth.debug.trace_transaction(
+                txn_hash_with_log,
+                {"tracer": "prestateTracer", "tracerConfig": {"diffMode": True}},
+            ),
+        )
+        assert "post" in dict(result).keys()
+        assert "pre" in dict(result).keys()
+
+    @pytest.mark.asyncio
+    async def test_async_geth_debug_trace_transaction_prestate_tracer(
+        self,
+        async_w3: "AsyncWeb3",
+        txn_hash_with_log: HexStr,
+        async_block_with_txn_with_log: BlockData,
+    ) -> None:
+        result = cast(
+            PrestateTrace,
+            await async_w3.geth.debug.trace_transaction(
+                txn_hash_with_log,
+                {"tracer": "prestateTracer"},
+            ),
+        )
+        tx = await async_w3.eth.get_transaction(txn_hash_with_log)
+        from_addr: ChecksumAddress = tx["from"]
+        assert isinstance(result[from_addr].get("balance"), int)
+        assert "post" not in dict(result).keys()
+        assert "pre" not in dict(result).keys()
+
+
+class GoEthereumDebugModuleTest:
+    def test_geth_debug_trace_transaction_opcode_logger(
+        self, w3: "Web3", txn_hash_with_log: HexStr
+    ) -> None:
+        result = cast(OpcodeTrace, w3.geth.debug.trace_transaction(txn_hash_with_log))
+        assert "structLogs" in dict(result).keys()
+        assert "gas" in dict(result).keys()
+        assert "failed" in dict(result).keys()
+
+    def test_geth_debug_trace_transaction_call_tracer(
+        self, w3: "Web3", txn_hash_with_log: HexStr
+    ) -> None:
+        result = cast(
+            CallTrace,
+            w3.geth.debug.trace_transaction(
+                txn_hash_with_log, {"tracer": "callTracer"}
+            ),
+        )
+        assert result.get("type") == "CALL"
+
+    def test_geth_debug_trace_transaction_prestate_tracer_diffmode(
+        self, w3: "Web3", txn_hash_with_log: HexStr
+    ) -> None:
+        result = cast(
+            DiffModeTrace,
+            w3.geth.debug.trace_transaction(
+                txn_hash_with_log,
+                {"tracer": "prestateTracer", "tracerConfig": {"diffMode": True}},
+            ),
+        )
+        assert "post" in dict(result).keys()
+        assert "pre" in dict(result).keys()
+
+    def test_geth_debug_trace_transaction_prestate_tracer(
+        self, w3: "Web3", txn_hash_with_log: HexStr
+    ) -> None:
+        result = cast(
+            PrestateTrace,
+            w3.geth.debug.trace_transaction(
+                txn_hash_with_log,
+                {"tracer": "prestateTracer"},
+            ),
+        )
+        tx = w3.eth.get_transaction(txn_hash_with_log)
+        from_addr: ChecksumAddress = tx["from"]
+        assert isinstance(result[from_addr].get("balance"), int)
+        assert "post" not in dict(result).keys()
+        assert "pre" not in dict(result).keys()

web3/_utils/module_testing/module_testing_utils.py

@@ -1,17 +1,22 @@
-from collections import (
-    deque,
-)
+import asyncio
+import functools
+import pytest
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Collection,
     Dict,
     Generator,
+    Literal,
     Sequence,
+    Tuple,
+    Type,
     Union,
 )
 
 from aiohttp import (
+    ClientSession,
     ClientTimeout,
 )
 from eth_typing import (
@@ -27,13 +32,10 @@ from flaky import (
 from hexbytes import (
     HexBytes,
 )
+import requests
 
-from web3._utils.compat import (
-    Literal,
-)
-from web3._utils.request import (
-    async_cache_and_return_session,
-    cache_and_return_session,
+from web3._utils.http import (
+    DEFAULT_HTTP_TIMEOUT,
 )
 from web3.types import (
     BlockData,
@@ -42,7 +44,9 @@ from web3.types import (
 
 if TYPE_CHECKING:
     from _pytest.monkeypatch import MonkeyPatch  # noqa: F401
-    from aiohttp import ClientResponse  # noqa: F401
+    from aiohttp import (  # noqa: F401
+        ClientResponse,
+    )
     from requests import Response  # noqa: F401
 
     from web3 import Web3  # noqa: F401
@@ -56,7 +60,44 @@ flaky_geth_dev_mining decorator for tests requiring a pending block
 for the duration of the test. This behavior can be flaky
 due to timing of the test running as a block is mined.
 """
-flaky_geth_dev_mining = flaky(max_runs=3)
+flaky_geth_dev_mining = flaky(max_runs=3, min_passes=1)
+
+
+def flaky_with_xfail_on_exception(
+    reason: str,
+    exception: Union[Type[Exception], Tuple[Type[Exception], ...]],
+    max_runs: int = 3,
+    min_passes: int = 1,
+) -> Callable[[Any], Any]:
+    """
+    Some tests inconsistently fail hard with a particular exception and retrying
+    these tests often times does not get them "unstuck". If we've exhausted all flaky
+    retries and this expected exception is raised, `xfail` the test with the given
+    reason.
+    """
+    runs = max_runs
+
+    def decorator(func: Any) -> Any:
+        @flaky(max_runs=max_runs, min_passes=min_passes)
+        @functools.wraps(func)
+        async def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
+            nonlocal runs
+            try:
+                return await func(self, *args, **kwargs)
+            except exception:
+                # xfail the test only if the exception is raised and we have exhausted
+                # all flaky retries
+                if runs == 1:
+                    pytest.xfail(reason)
+                runs -= 1
+                pytest.fail(f"xfailed but {runs} run(s) remaining with flaky...")
+            except Exception as e:
+                # let flaky handle it
+                raise e
+
+        return wrapper
+
+    return decorator
 
 
 def assert_contains_log(
@@ -65,7 +106,7 @@ def assert_contains_log(
     emitter_contract_address: ChecksumAddress,
     txn_hash_with_log: HexStr,
 ) -> None:
-    assert len(result) == 1
+    assert len(result) > 0
     log_entry = result[0]
     assert log_entry["blockNumber"] == block_with_txn_with_log["number"]
     assert log_entry["blockHash"] == block_with_txn_with_log["hash"]
@@ -104,13 +145,13 @@ def mock_offchain_lookup_request_response(
 
         # mock response only to specified url while validating appropriate fields
         if url_from_args == mocked_request_url:
-            assert kwargs["timeout"] == 30
+            assert kwargs["timeout"] == DEFAULT_HTTP_TIMEOUT
             if http_method.upper() == "POST":
-                assert kwargs["data"] == {"data": calldata, "sender": sender}
+                assert kwargs["json"] == {"data": calldata, "sender": sender}
             return MockedResponse()
 
         # else, make a normal request (no mocking)
-        session = cache_and_return_session(url_from_args)
+        session = requests.Session()
         return session.request(method=http_method.upper(), url=url_from_args, **kwargs)
 
     monkeypatch.setattr(
@@ -154,16 +195,18 @@ def async_mock_offchain_lookup_request_response(
 
         # mock response only to specified url while validating appropriate fields
         if url_from_args == mocked_request_url:
-            assert kwargs["timeout"] == ClientTimeout(30)
-            if http_method.upper() == "post":
-                assert kwargs["data"] == {"data": calldata, "sender": sender}
+            assert kwargs["timeout"] == ClientTimeout(DEFAULT_HTTP_TIMEOUT)
+            if http_method.upper() == "POST":
+                assert kwargs["json"] == {"data": calldata, "sender": sender}
             return AsyncMockedResponse()
 
         # else, make a normal request (no mocking)
-        session = await async_cache_and_return_session(url_from_args)
-        return await session.request(
+        session = ClientSession()
+        response = await session.request(
             method=http_method.upper(), url=url_from_args, **kwargs
         )
+        await session.close()
+        return response
 
     monkeypatch.setattr(
         f"aiohttp.ClientSession.{http_method.lower()}", _mock_specific_request
@@ -176,20 +219,34 @@ class WebSocketMessageStreamMock:
     def __init__(
         self, messages: Collection[bytes] = None, raise_exception: Exception = None
     ) -> None:
-        self.messages = deque(messages) if messages else deque()
+        self.queue = asyncio.Queue()  # type: ignore  # py38 issue
+        for msg in messages or []:
+            self.queue.put_nowait(msg)
         self.raise_exception = raise_exception
 
+    def __await__(self) -> Generator[Any, Any, "Self"]:
+        async def __async_init__() -> "Self":
+            return self
+
+        return __async_init__().__await__()
+
     def __aiter__(self) -> "Self":
         return self
 
     async def __anext__(self) -> bytes:
+        return await self.queue.get()
+
+    async def recv(self) -> bytes:
         if self.raise_exception:
             raise self.raise_exception
+        return await self.queue.get()
 
-        elif len(self.messages) == 0:
-            raise StopAsyncIteration
+    @staticmethod
+    async def pong() -> Literal[False]:
+        return False
 
-        return self.messages.popleft()
+    async def connect(self) -> None:
+        pass
 
     async def send(self, data: bytes) -> None:
         pass