Merge pull request #2639 from opentensor/tests/zyzniewski/fix_e2e

Fix e2e tests

Author: basfroman

tests/e2e_tests/conftest.py

@@ -8,11 +8,13 @@
 
 import pytest
 from async_substrate_interface import SubstrateInterface
+from bittensor.core.subtensor import Subtensor
 
 from bittensor.utils.btlogging import logging
 from tests.e2e_tests.utils.e2e_test_utils import (
     clone_or_update_templates,
     install_templates,
+    setup_wallet,
     template_path,
     uninstall_templates,
 )
@@ -103,3 +105,26 @@ def read_output():
     # uninstall templates
     logging.info("uninstalling neuron templates")
     uninstall_templates(template_path)
+
+
+@pytest.fixture
+def subtensor(local_chain):
+    return Subtensor(network="ws://localhost:9945")
+
+
+@pytest.fixture
+def alice_wallet():
+    keypair, wallet = setup_wallet("//Alice")
+    return wallet
+
+
+@pytest.fixture
+def bob_wallet():
+    keypair, wallet = setup_wallet("//Bob")
+    return wallet
+
+
+@pytest.fixture
+def dave_wallet():
+    keypair, wallet = setup_wallet("//Dave")
+    return wallet

tests/e2e_tests/test_axon.py

@@ -3,19 +3,15 @@
 
 import pytest
 
-import bittensor
-from bittensor.core.subtensor import Subtensor
 from bittensor.utils import networking
-from tests.e2e_tests.utils.chain_interactions import register_subnet
 from tests.e2e_tests.utils.e2e_test_utils import (
-    setup_wallet,
     template_path,
     templates_repo,
 )
 
 
 @pytest.mark.asyncio
-async def test_axon(local_chain):
+async def test_axon(subtensor, alice_wallet):
     """
     Test the Axon mechanism and successful registration on the network.
 
@@ -30,33 +26,24 @@ async def test_axon(local_chain):
 
     print("Testing test_axon")
 
-    netuid = 1
-    # Register root as Alice - the subnet owner
-    alice_keypair, wallet = setup_wallet("//Alice")
+    netuid = 2
 
-    subtensor = Subtensor(network="ws://localhost:9945")
+    # Register a subnet, netuid 2
+    assert subtensor.register_subnet(alice_wallet), "Subnet wasn't created"
 
-    # Register a subnet, netuid 1
-    assert register_subnet(local_chain, wallet), "Subnet wasn't created"
+    # Verify subnet <netuid> created successfully
+    assert subtensor.subnet_exists(netuid), "Subnet wasn't created successfully"
 
-    # Verify subnet <netuid 1> created successfully
-    assert local_chain.query(
-        "SubtensorModule", "NetworksAdded", [netuid]
-    ).serialize(), "Subnet wasn't created successfully"
-
-    # Register Alice to the network
-    assert subtensor.burned_register(
-        wallet, netuid
-    ), f"Neuron wasn't registered to subnet {netuid}"
-
-    metagraph = bittensor.Metagraph(netuid=netuid, network="ws://localhost:9945")
+    metagraph = subtensor.metagraph(netuid)
 
     # Validate current metagraph stats
     old_axon = metagraph.axons[0]
     assert len(metagraph.axons) == 1, f"Expected 1 axon, but got {len(metagraph.axons)}"
-    assert old_axon.hotkey == alice_keypair.ss58_address, "Hotkey mismatch for the axon"
     assert (
-        old_axon.coldkey == alice_keypair.ss58_address
+        old_axon.hotkey == alice_wallet.hotkey.ss58_address
+    ), "Hotkey mismatch for the axon"
+    assert (
+        old_axon.coldkey == alice_wallet.coldkey.ss58_address
     ), "Coldkey mismatch for the axon"
     assert old_axon.ip == "0.0.0.0", f"Expected IP 0.0.0.0, but got {old_axon.ip}"
     assert old_axon.port == 0, f"Expected port 0, but got {old_axon.port}"
@@ -66,17 +53,17 @@ async def test_axon(local_chain):
     cmd = " ".join(
         [
             f"{sys.executable}",
-            f'"{template_path}{templates_repo}/neurons/miner.py"',
+            f'"{template_path}{templates_repo}/miner.py"',
             "--netuid",
             str(netuid),
             "--subtensor.network",
             "local",
             "--subtensor.chain_endpoint",
             "ws://localhost:9945",
             "--wallet.path",
-            wallet.path,
+            alice_wallet.path,
             "--wallet.name",
-            wallet.name,
+            alice_wallet.name,
             "--wallet.hotkey",
             "default",
         ]
@@ -95,7 +82,7 @@ async def test_axon(local_chain):
     await asyncio.sleep(5)
 
     # Refresh the metagraph
-    metagraph = bittensor.Metagraph(netuid=netuid, network="ws://localhost:9945")
+    metagraph = subtensor.metagraph(netuid)
     updated_axon = metagraph.axons[0]
     external_ip = networking.get_external_ip()
 
@@ -119,11 +106,11 @@ async def test_axon(local_chain):
     assert updated_axon.port == 8091, f"Expected port 8091, but got {updated_axon.port}"
 
     assert (
-        updated_axon.hotkey == alice_keypair.ss58_address
+        updated_axon.hotkey == alice_wallet.hotkey.ss58_address
     ), "Hotkey mismatch after mining"
 
     assert (
-        updated_axon.coldkey == alice_keypair.ss58_address
+        updated_axon.coldkey == alice_wallet.coldkey.ss58_address
     ), "Coldkey mismatch after mining"
 
     print("✅ Passed test_axon")

tests/e2e_tests/test_commit_reveal_v3.py

@@ -4,24 +4,20 @@
 import numpy as np
 import pytest
 from bittensor.utils.btlogging import logging
-from bittensor.core.subtensor import Subtensor
 from bittensor.utils.balance import Balance
 from bittensor.utils.weight_utils import convert_weights_and_uids_for_emit
 from tests.e2e_tests.utils.chain_interactions import (
-    add_stake,
-    register_subnet,
+    sudo_set_admin_utils,
     sudo_set_hyperparameter_bool,
     sudo_set_hyperparameter_values,
     wait_interval,
-    sudo_set_admin_utils,
     next_tempo,
 )
-from tests.e2e_tests.utils.e2e_test_utils import setup_wallet
 
 
 @pytest.mark.parametrize("local_chain", [False], indirect=True)
 @pytest.mark.asyncio
-async def test_commit_and_reveal_weights_cr3(local_chain):
+async def test_commit_and_reveal_weights_cr3(local_chain, subtensor, alice_wallet):
     """
     Tests the commit/reveal weights mechanism (CR3)
 
@@ -36,31 +32,16 @@ async def test_commit_and_reveal_weights_cr3(local_chain):
     Raises:
         AssertionError: If any of the checks or verifications fail
     """
-    netuid = 1
+    netuid = 2
     logging.console.info("Testing test_commit_and_reveal_weights")
 
     # Register root as Alice
-    keypair, alice_wallet = setup_wallet("//Alice")
-    assert register_subnet(local_chain, alice_wallet), "Unable to register the subnet"
-
-    # Verify subnet 1 created successfully
-    assert local_chain.query(
-        "SubtensorModule", "NetworksAdded", [1]
-    ).serialize(), "Subnet wasn't created successfully"
-
-    logging.console.info("Subnet 1 is registered")
+    assert subtensor.register_subnet(alice_wallet), "Unable to register the subnet"
 
-    subtensor = Subtensor(network="ws://localhost:9945")
+    # Verify subnet 2 created successfully
+    assert subtensor.subnet_exists(netuid), "Subnet wasn't created successfully"
 
-    # Register Alice to the subnet
-    assert subtensor.burned_register(
-        alice_wallet, netuid
-    ), "Unable to register Alice as a neuron"
-    logging.console.info("Registered Alice to subnet 1")
-
-    # Stake to become to top neuron after the first epoch
-    add_stake(local_chain, alice_wallet, Balance.from_tao(100_000))
-    logging.console.info("Stake added by Alice")
+    logging.console.info("Subnet 2 is registered")
 
     # Enable commit_reveal on the subnet
     assert sudo_set_hyperparameter_bool(
@@ -123,6 +104,10 @@ async def test_commit_and_reveal_weights_cr3(local_chain):
     logging.console.info(
         f"Checking if window is too low with Current block: {current_block}, next tempo: {upcoming_tempo}"
     )
+
+    # Wait for 2 tempos to pass as CR3 only reveals weights after 2 tempos
+    subtensor.wait_for_block(20)
+
     # Lower than this might mean weights will get revealed before we can check them
     if upcoming_tempo - current_block < 3:
         await wait_interval(
@@ -198,7 +183,6 @@ async def test_commit_and_reveal_weights_cr3(local_chain):
     # Fetch weights on the chain as they should be revealed now
     revealed_weights_ = subtensor.weights(netuid=netuid)
 
-    time.sleep(10)
     print("revealed weights", revealed_weights_)
     revealed_weights = revealed_weights_[0][1]
     # Assert correct weights were revealed