Fix unit tests + ruff

Author: thewhaleking

tests/unit_tests/asyncio_/test_substrate_interface.py

@@ -1,4 +1,4 @@
-import unittest.mock
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 from websockets.exceptions import InvalidURI
@@ -24,42 +24,70 @@ async def test_invalid_url_raises_exception():
 @pytest.mark.asyncio
 async def test_runtime_call(monkeypatch):
     substrate = AsyncSubstrateInterface("ws://localhost", _mock=True)
-    substrate._metadata = unittest.mock.Mock()
-    substrate.metadata_v15 = unittest.mock.Mock(
-        **{
-            "value.return_value": {
-                "apis": [
+
+    fake_runtime = MagicMock()
+    fake_metadata_v15 = MagicMock()
+    fake_metadata_v15.value.return_value = {
+        "apis": [
+            {
+                "name": "SubstrateApi",
+                "methods": [
                     {
-                        "name": "SubstrateApi",
-                        "methods": [
-                            {
-                                "name": "SubstrateMethod",
-                                "inputs": [],
-                                "output": "1",
-                            },
-                        ],
+                        "name": "SubstrateMethod",
+                        "inputs": [],
+                        "output": "1",
                     },
                 ],
             },
-        }
-    )
-    substrate.rpc_request = unittest.mock.AsyncMock(
-        return_value={
-            "result": "0x00",
+        ],
+        "types": {
+            "types": [
+                {
+                    "id": "1",
+                    "type": {
+                        "path": ["Vec"],
+                        "def": {"sequence": {"type": "4"}},
+                    },
+                },
+            ]
         },
+    }
+    fake_runtime.metadata_v15 = fake_metadata_v15
+    substrate.init_runtime = AsyncMock(return_value=fake_runtime)
+
+    # Patch encode_scale (should not be called in this test since no inputs)
+    substrate.encode_scale = AsyncMock()
+
+    # Patch decode_scale to produce a dummy value
+    substrate.decode_scale = AsyncMock(return_value="decoded_result")
+
+    # Patch RPC request with correct behavior
+    substrate.rpc_request = AsyncMock(
+        side_effect=lambda method, params: {
+            "result": "0x00" if method == "state_call" else {"parentHash": "0xDEADBEEF"}
+        }
     )
-    substrate.decode_scale = unittest.mock.AsyncMock()
 
+    # Patch get_block_runtime_info
+    substrate.get_block_runtime_info = AsyncMock(return_value={"specVersion": "1"})
+
+    # Run the call
     result = await substrate.runtime_call(
         "SubstrateApi",
         "SubstrateMethod",
     )
 
+    # Validate the result is wrapped in ScaleObj
     assert isinstance(result, ScaleObj)
-    assert result.value is substrate.decode_scale.return_value
+    assert result.value == "decoded_result"
 
-    substrate.rpc_request.assert_called_once_with(
-        "state_call",
-        ["SubstrateApi_SubstrateMethod", "", None],
-    )
+    # Check decode_scale called correctly
     substrate.decode_scale.assert_called_once_with("scale_info::1", b"\x00")
+
+    # encode_scale should not be called since no inputs
+    substrate.encode_scale.assert_not_called()
+
+    # Check RPC request called for the state_call
+    substrate.rpc_request.assert_any_call(
+        "state_call", ["SubstrateApi_SubstrateMethod", "", None]
+    )

tests/unit_tests/test_cache.py

@@ -28,6 +28,7 @@ async def test_cached_fetcher_fetches_and_caches():
     assert result3 == "result_key2"
     assert mock_method.await_count == 2
 
+
 @pytest.mark.asyncio
 async def test_cached_fetcher_handles_inflight_requests():
     """Tests that CachedFetcher waits for in-flight results instead of re-fetching."""
@@ -53,9 +54,11 @@ async def slow_method(x):
     result1, result2 = await asyncio.gather(task1, task2)
     assert result1 == result2 == "slow_result_key1"
 
+
 @pytest.mark.asyncio
 async def test_cached_fetcher_propagates_errors():
     """Tests that CachedFetcher correctly propagates errors."""
+
     async def error_method(x):
         raise ValueError("Boom!")
 
@@ -64,6 +67,7 @@ async def error_method(x):
     with pytest.raises(ValueError, match="Boom!"):
         await fetcher.execute("key1")
 
+
 @pytest.mark.asyncio
 async def test_cached_fetcher_eviction():
     """Tests that LRU eviction works in CachedFetcher."""
@@ -80,4 +84,4 @@ async def test_cached_fetcher_eviction():
     # key1 should be evicted
     assert "key1" not in fetcher._cache.cache
     assert "key2" in fetcher._cache.cache
-    assert "key3" in fetcher._cache.cache
+    assert "key3" in fetcher._cache.cache