Merge branch 'staging' into fix/thewhaleking/str-formatting-for-alpha

Author: thewhaleking

tests/unit_tests/conftest.py

@@ -1,5 +1,8 @@
 import pytest
 from aioresponses import aioresponses
+from async_substrate_interface.sync_substrate import SubstrateInterface
+
+import bittensor.core.subtensor
 
 
 @pytest.fixture
@@ -11,3 +14,30 @@ def force_legacy_torch_compatible_api(monkeypatch):
 def mock_aio_response():
     with aioresponses() as m:
         yield m
+
+
+@pytest.fixture
+def mock_substrate_interface(mocker):
+    mocked = mocker.MagicMock(
+        autospec=SubstrateInterface,
+    )
+
+    mocker.patch("bittensor.core.subtensor.SubstrateInterface", return_value=mocked)
+
+    return mocked
+
+
+@pytest.fixture
+def subtensor(mock_substrate_interface):
+    return bittensor.core.subtensor.Subtensor()
+
+
+@pytest.fixture
+def mock_get_external_ip(mocker):
+    mocked = mocker.Mock(
+        return_value="192.168.1.1",
+    )
+
+    mocker.patch("bittensor.utils.networking.get_external_ip", mocked)
+
+    return mocked

tests/unit_tests/extrinsics/asyncex/test_commit_reveal.py

@@ -11,7 +11,7 @@
 @pytest.fixture
 def subtensor(mocker):
     fake_substrate = mocker.AsyncMock()
-    fake_substrate.websocket.sock.getsockopt.return_value = 0
+    fake_substrate.websocket.socket.getsockopt.return_value = 0
     mocker.patch.object(
         subtensor_module, "AsyncSubstrateInterface", return_value=fake_substrate
     )

tests/unit_tests/extrinsics/test_commit_reveal.py

@@ -6,17 +6,6 @@
 from bittensor.core import subtensor as subtensor_module
 from bittensor.core.chain_data import SubnetHyperparameters
 from bittensor.core.extrinsics import commit_reveal
-from bittensor.core.subtensor import Subtensor
-
-
-@pytest.fixture
-def subtensor(mocker):
-    fake_substrate = mocker.MagicMock()
-    fake_substrate.websocket.sock.getsockopt.return_value = 0
-    mocker.patch.object(
-        subtensor_module, "SubstrateInterface", return_value=fake_substrate
-    )
-    yield Subtensor()
 
 
 @pytest.fixture

tests/unit_tests/extrinsics/test_commit_weights.py

@@ -1,23 +1,10 @@
-import pytest
 from bittensor_wallet import Wallet
 
-from bittensor.core import subtensor as subtensor_module
-from bittensor.core.settings import version_as_int
-from bittensor.core.subtensor import Subtensor
 from bittensor.core.extrinsics.commit_weights import (
     _do_commit_weights,
     _do_reveal_weights,
 )
-
-
-@pytest.fixture
-def subtensor(mocker):
-    fake_substrate = mocker.MagicMock()
-    fake_substrate.websocket.sock.getsockopt.return_value = 0
-    mocker.patch.object(
-        subtensor_module, "SubstrateInterface", return_value=fake_substrate
-    )
-    return Subtensor()
+from bittensor.core.settings import version_as_int
 
 
 def test_do_commit_weights(subtensor, mocker):

tests/unit_tests/extrinsics/test_transfer.py

@@ -1,21 +1,7 @@
-import pytest
-
-from bittensor.core import subtensor as subtensor_module
 from bittensor.core.extrinsics.transfer import _do_transfer
-from bittensor.core.subtensor import Subtensor
 from bittensor.utils.balance import Balance
 
 
-@pytest.fixture
-def subtensor(mocker):
-    fake_substrate = mocker.MagicMock()
-    fake_substrate.websocket.sock.getsockopt.return_value = 0
-    mocker.patch.object(
-        subtensor_module, "SubstrateInterface", return_value=fake_substrate
-    )
-    return Subtensor()
-
-
 def test_do_transfer_is_success_true(subtensor, mocker):
     """Successful do_transfer call."""
     # Prep

tests/unit_tests/test_axon.py

@@ -1,18 +1,23 @@
+import asyncio
+import contextlib
 import re
+import threading
 import time
 from dataclasses import dataclass
 from typing import Any, Optional, Tuple
 from unittest import IsolatedAsyncioTestCase
 from unittest.mock import AsyncMock, MagicMock, patch
 
+import aiohttp
 import fastapi
 import netaddr
 import pydantic
 import pytest
+import uvicorn
 from fastapi.testclient import TestClient
 from starlette.requests import Request
 
-from bittensor.core.axon import AxonMiddleware, Axon
+from bittensor.core.axon import Axon, AxonMiddleware, FastAPIThreadedServer
 from bittensor.core.errors import RunException
 from bittensor.core.settings import version_as_int
 from bittensor.core.stream import StreamingSynapse
@@ -26,7 +31,7 @@
 )
 
 
-def test_attach_initial():
+def test_attach_initial(mock_get_external_ip):
     # Create a mock AxonServer instance
     server = Axon()
 
@@ -71,7 +76,7 @@ def wrong_verify_fn(synapse: TestSynapse) -> bool:
         server.attach(forward_fn, blacklist_fn, priority_fn, wrong_verify_fn)
 
 
-def test_attach():
+def test_attach(mock_get_external_ip):
     # Create a mock AxonServer instance
     server = Axon()
 
@@ -144,7 +149,7 @@ def mock_request():
 
 
 @pytest.fixture
-def axon_instance():
+def axon_instance(mock_get_external_ip):
     axon = Axon()
     axon.required_hash_fields = {"test_endpoint": ["field1", "field2"]}
     axon.forward_class_types = {
@@ -329,7 +334,7 @@ async def test_verify_body_integrity_error_cases(
         (MockInfo(), "MockInfoString", "edge_case_empty_string"),
     ],
 )
-def test_to_string(info_return, expected_output, test_id):
+def test_to_string(info_return, expected_output, test_id, mock_get_external_ip):
     # Arrange
     axon = Axon()
     with patch.object(axon, "info", return_value=info_return):
@@ -358,7 +363,9 @@ def test_to_string(info_return, expected_output, test_id):
         ),
     ],
 )
-def test_valid_ipv4_and_ipv6_address(ip, port, expected_ip_type, test_id):
+def test_valid_ipv4_and_ipv6_address(
+    ip, port, expected_ip_type, test_id, mock_get_external_ip
+):
     # Arrange
     hotkey = MockHotkey("5EemgxS7cmYbD34esCFoBgUZZC8JdnGtQvV5Qw3QFUCRRtGP")
     coldkey = MockHotkey("5EemgxS7cmYbD34esCFoBgUZZC8JdnGtQvV5Qw3QFUCRRtGP")
@@ -431,7 +438,14 @@ def test_invalid_ip_address(ip, port, expected_exception):
     ],
 )
 def test_axon_str_representation(
-    ip, port, ss58_address, started, forward_fns, expected_str, test_id
+    ip,
+    port,
+    ss58_address,
+    started,
+    forward_fns,
+    expected_str,
+    test_id,
+    mock_get_external_ip,
 ):
     # Arrange
     hotkey = MockHotkey(ss58_address)
@@ -765,3 +779,50 @@ async def forward_fn(synapse: streaming_synapse_cls):
                 "computed_body_hash": "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a",
             },
         )
+
+
+@pytest.mark.asyncio
+async def test_threaded_fastapi():
+    server_started = threading.Event()
+    server_stopped = threading.Event()
+
+    @contextlib.asynccontextmanager
+    async def lifespan(app):
+        server_started.set()
+        yield
+        server_stopped.set()
+
+    app = fastapi.FastAPI(
+        lifespan=lifespan,
+    )
+    app.get("/")(lambda: "Hello World")
+
+    server = FastAPIThreadedServer(
+        uvicorn.Config(app, loop="none"),
+    )
+    server.start()
+
+    server_started.wait(3.0)
+
+    async def wait_for_server():
+        while not (server.started or server_stopped.is_set()):
+            await asyncio.sleep(1.0)
+
+    await asyncio.wait_for(wait_for_server(), 7.0)
+
+    assert server.is_running is True
+
+    async with aiohttp.ClientSession(
+        base_url="http://127.0.0.1:8000",
+    ) as session:
+        async with session.get("/") as response:
+            assert await response.text() == '"Hello World"'
+
+        server.stop()
+
+        assert server.should_exit is True
+
+        server_stopped.wait()
+
+        with pytest.raises(aiohttp.ClientConnectorError):
+            await session.get("/")

tests/unit_tests/test_dendrite.py

@@ -29,7 +29,7 @@ def dummy(synapse: SynapseDummy) -> SynapseDummy:
 
 
 @pytest.fixture
-def setup_dendrite():
+def setup_dendrite(mock_get_external_ip):
     # Assuming bittensor.Wallet() returns a wallet object
     user_wallet = get_mock_wallet()
     dendrite_obj = Dendrite(user_wallet)
@@ -51,7 +51,10 @@ def axon_info():
 @pytest.fixture(scope="session")
 def setup_axon():
     wallet = get_mock_wallet()
-    axon = Axon(wallet)
+    axon = Axon(
+        wallet,
+        external_ip="192.168.1.1",
+    )
     axon.attach(forward_fn=dummy)
     axon.start()
     yield axon
@@ -103,15 +106,15 @@ def __await__(self):
         return self().__await__()
 
 
-def test_dendrite_create_wallet():
+def test_dendrite_create_wallet(mock_get_external_ip):
     d = Dendrite(get_mock_wallet())
     d = Dendrite(get_mock_wallet().hotkey)
     d = Dendrite(get_mock_wallet().coldkeypub)
     assert d.__str__() == d.__repr__()
 
 
 @pytest.mark.asyncio
-async def test_forward_many():
+async def test_forward_many(mock_get_external_ip):
     n = 10
     d = Dendrite(wallet=get_mock_wallet())
     d.call = AsyncMock()
@@ -128,7 +131,7 @@ async def test_forward_many():
     assert len([resp]) == 1
 
 
-def test_pre_process_synapse():
+def test_pre_process_synapse(mock_get_external_ip):
     d = Dendrite(wallet=get_mock_wallet())
     s = Synapse()
     synapse = d.preprocess_synapse_for_request(

tests/unit_tests/test_subtensor.py

@@ -73,7 +73,7 @@ def call_params_with_certificate():
     return params
 
 
-def test_methods_comparable(mocker):
+def test_methods_comparable(mock_substrate_interface):
     """Verifies that methods in sync and async Subtensors are comparable."""
     # Preps
     subtensor = Subtensor(_mock=True)
@@ -142,9 +142,7 @@ def test_serve_axon_with_external_ip_set():
     assert axon_info.ip == external_ip
 
 
-def test_serve_axon_with_external_port_set():
-    external_ip: str = "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
-
+def test_serve_axon_with_external_port_set(mock_get_external_ip):
     internal_port: int = 1234
     external_port: int = 5678
 
@@ -179,14 +177,10 @@ def test_serve_axon_with_external_port_set():
         config=mock_config,
     )
 
-    with mock.patch(
-        "bittensor.utils.networking.get_external_ip", return_value=external_ip
-    ):
-        # mock the get_external_ip function to return the external ip
-        mock_subtensor.serve_axon(
-            netuid=-1,
-            axon=mock_axon_with_external_port_set,
-        )
+    mock_subtensor.serve_axon(
+        netuid=-1,
+        axon=mock_axon_with_external_port_set,
+    )
 
     mock_serve_axon.assert_called_once()
     # verify that the axon is served to the network with the external port
@@ -294,24 +288,6 @@ def test_determine_chain_endpoint_and_network(
     assert result_endpoint == expected_endpoint
 
 
-@pytest.fixture
-def subtensor(mocker):
-    fake_substrate = mocker.MagicMock()
-    fake_substrate.websocket.sock.getsockopt.return_value = 0
-    mocker.patch.object(
-        subtensor_module, "SubstrateInterface", return_value=fake_substrate
-    )
-    mocker.patch.object(
-        sync_substrate,
-        "connect",
-        return_value=mocker.MagicMock(),
-    )
-    fake_websocket = mocker.MagicMock()
-    fake_websocket.client.connect.return_value = 0
-    # mocker.patch.object(subtensor_module, "ws_client", return_value=fake_websocket)
-    return Subtensor()
-
-
 @pytest.fixture
 def mock_logger():
     with mock.patch.object(logging, "warning") as mock_warning: