Merge pull request #2596 from opentensor/fix/2472-offline_unittests

test(2472): offline unittests

Author: zyzniewski-reef

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

@@ -31,7 +31,7 @@
 )
 
 
-def test_attach_initial():
+def test_attach_initial(mock_get_external_ip):
     # Create a mock AxonServer instance
     server = Axon()
 
@@ -76,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()
 
@@ -149,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 = {
@@ -334,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):
@@ -363,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")
@@ -436,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)

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:

tests/unit_tests/utils/test_networking.py

@@ -83,13 +83,42 @@ def test_int_to_ip6_underflow():
 
 
 # Test getting external IP address
-def test_get_external_ip():
+def test_get_external_ip(mocker):
     """Test getting the external IP address."""
-    assert utils.networking.get_external_ip()
+    mocked_requests_get = mock.Mock(
+        return_value=mock.Mock(
+            **{
+                "text": "192.168.1.1",
+            },
+        ),
+    )
+
+    mocker.patch.object(
+        requests,
+        "get",
+        mocked_requests_get,
+    )
+
+    assert utils.networking.get_external_ip() == "192.168.1.1"
+
+    mocked_requests_get.assert_called_once_with("https://checkip.amazonaws.com")
 
 
-def test_get_external_ip_os_broken():
+def test_get_external_ip_os_broken(mocker):
     """Test getting the external IP address when os.popen is broken."""
+    mocked_requests_get = mock.Mock(
+        return_value=mock.Mock(
+            **{
+                "text": "192.168.1.1",
+            },
+        ),
+    )
+
+    mocker.patch.object(
+        requests,
+        "get",
+        mocked_requests_get,
+    )
 
     class FakeReadline:
         def readline(self):
@@ -99,7 +128,9 @@ def mock_call():
         return FakeReadline()
 
     with mock.patch.object(os, "popen", new=mock_call):
-        assert utils.networking.get_external_ip()
+        assert utils.networking.get_external_ip() == "192.168.1.1"
+
+    mocked_requests_get.assert_called_once_with("https://checkip.amazonaws.com")
 
 
 def test_get_external_ip_os_request_urllib_broken():