chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/cmds/test_cmd_framework.py

@@ -1,28 +1,45 @@
 from __future__ import annotations
 
+import pathlib
 import textwrap
+from collections.abc import Sequence
 from dataclasses import asdict
-from typing import Any, Dict, List, Optional, Sequence
+from decimal import Decimal
+from typing import Any, Optional
 
 import click
 import pytest
 from click.testing import CliRunner
 
-from chia._tests.conftest import ConsensusMode
-from chia._tests.environments.wallet import WalletTestFramework
+from chia._tests.environments.wallet import STANDARD_TX_ENDPOINT_ARGS, WalletTestFramework
 from chia._tests.wallet.conftest import *  # noqa
-from chia.cmds.cmd_classes import ChiaCommand, Context, NeedsWalletRPC, chia_command, option
+from chia.cmds.cmd_classes import ChiaCliContext, ChiaCommand, chia_command, option
+from chia.cmds.cmd_helpers import (
+    _TRANSACTION_ENDPOINT_DECORATOR_APPLIED,
+    NeedsCoinSelectionConfig,
+    NeedsTXConfig,
+    NeedsWalletRPC,
+    TransactionEndpoint,
+    TransactionEndpointWithTimelocks,
+    transaction_endpoint_runner,
+)
+from chia.cmds.cmds_util import coin_selection_args, tx_config_args, tx_out_cmd
+from chia.cmds.param_types import CliAmount
 from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint64
+from chia.wallet.conditions import ConditionValidTimes
+from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.util.tx_config import CoinSelectionConfig, TXConfig
 
 
-def check_click_parsing(cmd: ChiaCommand, *args: str) -> None:
+def check_click_parsing(cmd: ChiaCommand, *args: str, context: Optional[ChiaCliContext] = None) -> None:
     @click.group()
     def _cmd() -> None:
         pass
 
     mock_type = type(cmd.__class__.__name__, (cmd.__class__,), {})
 
-    def dict_compare_with_ignore_context(one: Dict[str, Any], two: Dict[str, Any]) -> None:
+    def dict_compare_with_ignore_context(one: dict[str, Any], two: dict[str, Any]) -> None:
         for k, v in one.items():
             if k == "context":
                 continue
@@ -35,11 +52,17 @@ def check_click_parsing(cmd: ChiaCommand, *args: str) -> None:
         # cmd is appropriately not recognized as a dataclass but I'm not sure how to hint that something is a dataclass
         dict_compare_with_ignore_context(asdict(cmd), asdict(self))  # type: ignore[call-overload]
 
+    # We hack this in because more robust solutions are harder and probably not worth it
+    setattr(new_run, _TRANSACTION_ENDPOINT_DECORATOR_APPLIED, True)
+
     setattr(mock_type, "run", new_run)
-    chia_command(_cmd, "_", "")(mock_type)
+    chia_command(group=_cmd, name="_", short_help="", help="")(mock_type)
+
+    if context is None:
+        context = ChiaCliContext()
 
     runner = CliRunner()
-    result = runner.invoke(_cmd, ["_", *args], catch_exceptions=False)
+    result = runner.invoke(_cmd, ["_", *args], catch_exceptions=False, obj=context.to_click())
     assert result.output == ""
 
 
@@ -48,12 +71,12 @@ def test_cmd_bases() -> None:
     def cmd() -> None:
         pass
 
-    @chia_command(cmd, "temp_cmd", "blah")
+    @chia_command(group=cmd, name="temp_cmd", short_help="blah", help="n/a")
     class TempCMD:
         def run(self) -> None:
             print("syncronous")
 
-    @chia_command(cmd, "temp_cmd_async", "blah")
+    @chia_command(group=cmd, name="temp_cmd_async", short_help="blah", help="n/a")
     class TempCMDAsync:
         async def run(self) -> None:
             print("asyncronous")
@@ -95,14 +118,15 @@ def test_option_loading() -> None:
     def cmd() -> None:
         pass
 
-    @chia_command(cmd, "temp_cmd", "blah")
+    @chia_command(group=cmd, name="temp_cmd", short_help="blah", help="n/a")
     class TempCMD:
         some_option: int = option("-o", "--some-option", required=True, type=int)
+        choices: list[str] = option("--choice", multiple=True, type=str)
 
         def run(self) -> None:
             print(self.some_option)
 
-    @chia_command(cmd, "temp_cmd_2", "blah")
+    @chia_command(group=cmd, name="temp_cmd_2", short_help="blah", help="n/a")
     class TempCMD2:
         some_option: int = option("-o", "--some-option", required=True, type=int, default=13)
 
@@ -142,14 +166,14 @@ def test_context_requirement() -> None:
     @click.group()
     @click.pass_context
     def cmd(ctx: click.Context) -> None:
-        ctx.obj = {"foo": "bar"}
+        ctx.obj = ChiaCliContext(root_path=pathlib.Path("foo", "bar")).to_click()
 
-    @chia_command(cmd, "temp_cmd", "blah")
+    @chia_command(group=cmd, name="temp_cmd", short_help="blah", help="n/a")
     class TempCMD:
-        context: Context
+        context: ChiaCliContext
 
         def run(self) -> None:
-            assert self.context["foo"] == "bar"
+            assert self.context.root_path == pathlib.Path("foo", "bar")
 
     runner = CliRunner()
     result = runner.invoke(
@@ -162,7 +186,7 @@ def test_context_requirement() -> None:
     # Test that other variables named context are disallowed
     with pytest.raises(ValueError, match="context"):
 
-        @chia_command(cmd, "shouldnt_work", "blah")
+        @chia_command(group=cmd, name="shouldnt_work", short_help="blah", help="n/a")
         class BadCMD:
             context: int
 
@@ -174,7 +198,7 @@ def test_typing() -> None:
     def cmd() -> None:
         pass
 
-    @chia_command(cmd, "temp_cmd", "blah")
+    @chia_command(group=cmd, name="temp_cmd", short_help="blah", help="n/a")
     class TempCMD:
         integer: int = option("--integer", default=1, required=False)
         text: str = option("--text", default="1", required=False)
@@ -206,7 +230,7 @@ def test_typing() -> None:
     )
 
     # Test optional
-    @chia_command(cmd, "temp_cmd_optional", "blah")
+    @chia_command(group=cmd, name="temp_cmd_optional", short_help="blah", help="n/a")
     class TempCMDOptional:
         optional: Optional[int] = option("--optional", required=False)
 
@@ -218,7 +242,7 @@ def test_typing() -> None:
     # Test optional failure
     with pytest.raises(TypeError):
 
-        @chia_command(cmd, "temp_cmd_optional_bad", "blah")
+        @chia_command(group=cmd, name="temp_cmd_optional_bad", short_help="blah", help="n/a")
         class TempCMDOptionalBad2:
             optional: Optional[int] = option("--optional", required=True)
 
@@ -226,20 +250,20 @@ def test_typing() -> None:
 
     with pytest.raises(TypeError):
 
-        @chia_command(cmd, "temp_cmd_optional_bad", "blah")
+        @chia_command(group=cmd, name="temp_cmd_optional_bad", short_help="blah", help="n/a")
         class TempCMDOptionalBad3:
             optional: Optional[int] = option("--optional", default="string", required=False)
 
             def run(self) -> None: ...
 
-    @chia_command(cmd, "temp_cmd_optional_fine", "blah")
+    @chia_command(group=cmd, name="temp_cmd_optional_fine", short_help="blah", help="n/a")
     class TempCMDOptionalBad4:
         optional: Optional[int] = option("--optional", default=None, required=False)
 
         def run(self) -> None: ...
 
     # Test multiple
-    @chia_command(cmd, "temp_cmd_sequence", "blah")
+    @chia_command(group=cmd, name="temp_cmd_sequence", short_help="blah", help="n/a")
     class TempCMDSequence:
         sequence: Sequence[int] = option("--sequence", multiple=True)
 
@@ -251,7 +275,7 @@ def test_typing() -> None:
     # Test sequence failure
     with pytest.raises(TypeError):
 
-        @chia_command(cmd, "temp_cmd_sequence_bad", "blah")
+        @chia_command(group=cmd, name="temp_cmd_sequence_bad", short_help="blah", help="n/a")
         class TempCMDSequenceBad:
             sequence: Sequence[int] = option("--sequence")
 
@@ -259,7 +283,7 @@ def test_typing() -> None:
 
     with pytest.raises(TypeError):
 
-        @chia_command(cmd, "temp_cmd_sequence_bad", "blah")
+        @chia_command(group=cmd, name="temp_cmd_sequence_bad", short_help="blah", help="n/a")
         class TempCMDSequenceBad2:
             sequence: int = option("--sequence", multiple=True)
 
@@ -267,7 +291,7 @@ def test_typing() -> None:
 
     with pytest.raises(ValueError):
 
-        @chia_command(cmd, "temp_cmd_sequence_bad", "blah")
+        @chia_command(group=cmd, name="temp_cmd_sequence_bad", short_help="blah", help="n/a")
         class TempCMDSequenceBad3:
             sequence: Sequence[int] = option("--sequence", default=[1, 2, 3], multiple=True)
 
@@ -275,7 +299,7 @@ def test_typing() -> None:
 
     with pytest.raises(TypeError):
 
-        @chia_command(cmd, "temp_cmd_sequence_bad", "blah")
+        @chia_command(group=cmd, name="temp_cmd_sequence_bad", short_help="blah", help="n/a")
         class TempCMDSequenceBad4:
             sequence: Sequence[int] = option("--sequence", default=(1, 2, "3"), multiple=True)
 
@@ -284,29 +308,29 @@ def test_typing() -> None:
     # Test invalid type
     with pytest.raises(TypeError):
 
-        @chia_command(cmd, "temp_cmd_bad_type", "blah")
+        @chia_command(group=cmd, name="temp_cmd_bad_type", short_help="blah", help="n/a")
         class TempCMDBadType:
-            sequence: List[int] = option("--sequence")
+            sequence: list[int] = option("--sequence")
 
             def run(self) -> None: ...
 
     # Test invalid default
     with pytest.raises(TypeError):
 
-        @chia_command(cmd, "temp_cmd_bad_default", "blah")
+        @chia_command(group=cmd, name="temp_cmd_bad_default", short_help="blah", help="n/a")
         class TempCMDBadDefault:
             integer: int = option("--int", default="string")
 
             def run(self) -> None: ...
 
     # Test bytes parsing
-    @chia_command(cmd, "temp_cmd_bad_bytes", "blah")
+    @chia_command(group=cmd, name="temp_cmd_bad_bytes", short_help="blah", help="n/a")
     class TempCMDBadBytes:
         blob: bytes = option("--blob", required=True)
 
         def run(self) -> None: ...
 
-    @chia_command(cmd, "temp_cmd_bad_bytes32", "blah")
+    @chia_command(group=cmd, name="temp_cmd_bad_bytes32", short_help="blah", help="n/a")
     class TempCMDBadBytes32:
         blob32: bytes32 = option("--blob32", required=True)
 
@@ -328,7 +352,7 @@ def test_typing() -> None:
     assert "not a valid 32-byte hex string" in result.output
 
 
-@pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="doesn't matter")
+@pytest.mark.limit_consensus_modes(reason="doesn't matter")
 @pytest.mark.parametrize(
     "wallet_environments",
     [
@@ -352,7 +376,7 @@ async def test_wallet_rpc_helper(wallet_environments: WalletTestFramework) -> No
     def cmd() -> None:
         pass
 
-    @chia_command(cmd, "temp_cmd", "blah")
+    @chia_command(group=cmd, name="temp_cmd", short_help="blah", help="n/a")
     class TempCMD:
         rpc_info: NeedsWalletRPC
 
@@ -384,7 +408,7 @@ async def test_wallet_rpc_helper(wallet_environments: WalletTestFramework) -> No
 
     expected_command = TempCMD(
         rpc_info=NeedsWalletRPC(
-            context={"root_path": wallet_environments.environments[0].node.root_path},
+            context=ChiaCliContext(root_path=wallet_environments.environments[0].node.root_path),
             wallet_rpc_port=port,
             fingerprint=fingerprint,
         ),
@@ -398,3 +422,199 @@ async def test_wallet_rpc_helper(wallet_environments: WalletTestFramework) -> No
     test_present_client_info = TempCMD(rpc_info=NeedsWalletRPC(client_info="hello world"))  # type: ignore[arg-type]
     async with test_present_client_info.rpc_info.wallet_rpc(consume_errors=False) as client_info:
         assert client_info == "hello world"  # type: ignore[comparison-overlap]
+
+
+def test_tx_config_helper() -> None:
+    @click.group()
+    def cmd() -> None:
+        pass  # pragma: no cover
+
+    @chia_command(group=cmd, name="cs_cmd", short_help="blah", help="blah")
+    class CsCMD:
+        coin_selection_loader: NeedsCoinSelectionConfig
+
+        def run(self) -> None:
+            # ignoring the `None` return here for convenient testing sake
+            return self.coin_selection_loader.load_coin_selection_config(100)  # type: ignore[return-value]
+
+    example_cs_cmd = CsCMD(
+        coin_selection_loader=NeedsCoinSelectionConfig(
+            min_coin_amount=CliAmount(amount=Decimal("0.01"), mojos=False),
+            max_coin_amount=CliAmount(amount=Decimal("0.01"), mojos=False),
+            amounts_to_exclude=(CliAmount(amount=Decimal("0.01"), mojos=False),),
+            coins_to_exclude=(bytes32([0] * 32),),
+        )
+    )
+
+    check_click_parsing(
+        example_cs_cmd,
+        "--min-coin-amount",
+        "0.01",
+        "--max-coin-amount",
+        "0.01",
+        "--exclude-amount",
+        "0.01",
+        "--exclude-coin",
+        bytes32([0] * 32).hex(),
+    )
+
+    # again, convenience for testing sake
+    assert example_cs_cmd.run() == CoinSelectionConfig(  # type: ignore[func-returns-value]
+        min_coin_amount=uint64(1),
+        max_coin_amount=uint64(1),
+        excluded_coin_amounts=[uint64(1)],
+        excluded_coin_ids=[bytes32([0] * 32)],
+    )
+
+    @chia_command(group=cmd, name="tx_config_cmd", short_help="blah", help="blah")
+    class TXConfigCMD:
+        tx_config_loader: NeedsTXConfig
+
+        def run(self) -> None:
+            # ignoring the `None` return here for convenient testing sake
+            return self.tx_config_loader.load_tx_config(100, {}, 0)  # type: ignore[return-value]
+
+    example_tx_config_cmd = TXConfigCMD(
+        tx_config_loader=NeedsTXConfig(
+            min_coin_amount=CliAmount(amount=Decimal("0.01"), mojos=False),
+            max_coin_amount=CliAmount(amount=Decimal("0.01"), mojos=False),
+            amounts_to_exclude=(CliAmount(amount=Decimal("0.01"), mojos=False),),
+            coins_to_exclude=(bytes32([0] * 32),),
+            reuse=False,
+        )
+    )
+
+    check_click_parsing(
+        example_tx_config_cmd,
+        "--min-coin-amount",
+        "0.01",
+        "--max-coin-amount",
+        "0.01",
+        "--exclude-amount",
+        "0.01",
+        "--exclude-coin",
+        bytes32([0] * 32).hex(),
+        "--new-address",
+    )
+
+    # again, convenience for testing sake
+    assert example_tx_config_cmd.run() == TXConfig(  # type: ignore[func-returns-value]
+        min_coin_amount=uint64(1),
+        max_coin_amount=uint64(1),
+        excluded_coin_amounts=[uint64(1)],
+        excluded_coin_ids=[bytes32([0] * 32)],
+        reuse_puzhash=False,
+    )
+
+
+@pytest.mark.anyio
+async def test_transaction_endpoint_mixin() -> None:
+    @click.group()
+    def cmd() -> None:
+        pass  # pragma: no cover
+
+    @chia_command(group=cmd, name="bad_cmd", short_help="blah", help="blah")
+    class BadCMD(TransactionEndpoint):
+        def run(self) -> None:  # type: ignore[override]
+            pass  # pragma: no cover
+
+    with pytest.raises(TypeError, match="transaction_endpoint_runner"):
+        BadCMD(**STANDARD_TX_ENDPOINT_ARGS)
+
+    @chia_command(group=cmd, name="cs_cmd", short_help="blah", help="blah")
+    class TxCMD(TransactionEndpoint):
+        @transaction_endpoint_runner
+        async def run(self) -> list[TransactionRecord]:
+            assert self.load_condition_valid_times() == ConditionValidTimes(
+                min_time=uint64(10),
+                max_time=uint64(20),
+            )
+            return []
+
+    # Check that our default object lines up with the default options
+    check_click_parsing(TxCMD(**STANDARD_TX_ENDPOINT_ARGS))
+
+    example_tx_cmd = TxCMD(
+        **{
+            **STANDARD_TX_ENDPOINT_ARGS,
+            **dict(
+                fee=uint64(1_000_000_000_000 / 100),
+                push=False,
+                valid_at=10,
+                expires_at=20,
+            ),
+        }
+    )
+    check_click_parsing(
+        example_tx_cmd,
+        "--fee",
+        "0.01",
+        "--no-push",
+        "--valid-at",
+        "10",
+        "--expires-at",
+        "20",
+    )
+
+    await example_tx_cmd.run()  # trigger inner assert
+
+
+# While we sit in between two paradigms, this test is in place to ensure they remain in sync.
+# Delete this if the old decorators are deleted.
+def test_old_decorator_support() -> None:
+    @click.group()
+    def cmd() -> None:
+        pass  # pragma: no cover
+
+    @chia_command(group=cmd, name="cs_cmd", short_help="blah", help="blah")
+    class CsCMD:
+        coin_selection_loader: NeedsCoinSelectionConfig
+
+        def run(self) -> None:
+            pass  # pragma: no cover
+
+    @chia_command(group=cmd, name="tx_config_cmd", short_help="blah", help="blah")
+    class TXConfigCMD:
+        tx_config_loader: NeedsTXConfig
+
+        def run(self) -> None:
+            pass  # pragma: no cover
+
+    @chia_command(group=cmd, name="tx_cmd", short_help="blah", help="blah")
+    class TxCMD(TransactionEndpoint):
+        @transaction_endpoint_runner
+        async def run(self) -> list[TransactionRecord]:
+            return []  # pragma: no cover
+
+    @chia_command(group=cmd, name="tx_w_tl_cmd", short_help="blah", help="blah")
+    class TxWTlCMD(TransactionEndpointWithTimelocks):
+        @transaction_endpoint_runner
+        async def run(self) -> list[TransactionRecord]:
+            return []  # pragma: no cover
+
+    @cmd.command("cs_cmd_dec")
+    @coin_selection_args
+    def cs_cmd(**kwargs: Any) -> None:
+        pass  # pragma: no cover
+
+    @cmd.command("tx_config_cmd_dec")
+    @tx_config_args
+    def tx_config_cmd(**kwargs: Any) -> None:
+        pass  # pragma: no cover
+
+    @cmd.command("tx_cmd_dec")  # type: ignore[arg-type]
+    @tx_out_cmd(enable_timelock_args=False)
+    def tx_cmd(**kwargs: Any) -> None:
+        pass  # pragma: no cover
+
+    @cmd.command("tx_w_tl_cmd_dec")  # type: ignore[arg-type]
+    @tx_out_cmd(enable_timelock_args=True)
+    def tx_w_tl_cmd(**kwargs: Any) -> None:
+        pass  # pragma: no cover
+
+    for command_name, command in cmd.commands.items():
+        if "_dec" in command_name:
+            continue
+        params = [param.to_info_dict() for param in cmd.commands[command_name].params]
+        for param in cmd.commands[f"{command_name}_dec"].params:
+            assert param.to_info_dict() in params

chia/_tests/cmds/test_cmds_util.py

@@ -44,7 +44,7 @@ async def test_failure_output_no_traceback(
     ) as (client, _):
         await client.fetch(path="/table", request_json={"response": expected_response})
 
-    out, err = capsys.readouterr()
+    out, _err = capsys.readouterr()
 
     assert "ResponseFailureError" not in out
     assert "Traceback:" not in out
@@ -69,7 +69,7 @@ async def test_failure_output_with_traceback(
     ) as (client, _):
         await client.fetch(path="/table", request_json={"response": expected_response})
 
-    out, err = capsys.readouterr()
+    out, _err = capsys.readouterr()
     assert sample_traceback_json not in out
     assert sample_traceback in out
 

chia/_tests/cmds/test_daemon.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sys
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 import pytest
 from _pytest.capture import CaptureFixture
@@ -28,7 +28,7 @@ async def test_daemon(
         async def unlock_keyring(_passphrase: str) -> bool:
             return True
 
-    async def connect_to_daemon_and_validate(_root_path: Path, _config: Dict[str, Any]) -> DummyConnection:
+    async def connect_to_daemon_and_validate(_root_path: Path, _config: dict[str, Any]) -> DummyConnection:
         return DummyConnection()
 
     class DummyKeychain:
@@ -74,7 +74,7 @@ def test_start_daemon(tmp_path: Path, empty_keyring: Any, mocker: MockerFixture)
             return None
 
     async def create_start_daemon_connection_dummy(
-        root_path: Path, config: Dict[str, Any], *, skip_keyring: bool
+        root_path: Path, config: dict[str, Any], *, skip_keyring: bool
     ) -> DummyDaemon:
         return DummyDaemon()
 

chia/_tests/cmds/test_dev_gh.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+import aiohttp
+import anyio
+import click
+import pytest
+
+# TODO: update after resolution in https://github.com/pytest-dev/pytest/issues/7469
+from _pytest.capture import CaptureFixture
+
+import chia._tests
+from chia._tests.util.misc import Marks, datacases
+from chia.cmds.gh import Per, TestCMD, get_gh_token
+
+test_root = Path(chia._tests.__file__).parent
+
+
+@dataclass
+class InvalidOnlyCase:
+    only: Path
+    per: Per
+    exists: bool
+    marks: Marks = ()
+
+    @property
+    def id(self) -> str:
+        return f"{self.per}: {self.only}"
+
+
+@datacases(
+    InvalidOnlyCase(only=Path("does_not_exist.py"), per="directory", exists=False),
+    InvalidOnlyCase(only=Path("pools/test_pool_rpc.py"), per="directory", exists=True),
+    InvalidOnlyCase(only=Path("does_not_exist/"), per="file", exists=False),
+    InvalidOnlyCase(only=Path("pools/"), per="file", exists=True),
+)
+@pytest.mark.anyio
+async def test_invalid_only(case: InvalidOnlyCase) -> None:
+    cmd = TestCMD(only=case.only, per=case.per)
+
+    if case.exists:
+        assert test_root.joinpath(case.only).exists()
+        explanation = "wrong type"
+        if case.per == "directory":
+            assert test_root.joinpath(case.only).is_file()
+        else:
+            assert test_root.joinpath(case.only).is_dir()
+    else:
+        assert not test_root.joinpath(case.only).exists()
+        explanation = "does not exist"
+
+    with pytest.raises(click.ClickException, match=rf"\bto be a {re.escape(case.per)}\b.*\b{re.escape(explanation)}\b"):
+        await cmd.run()
+
+
+@pytest.mark.skip("considering inclusion, but not yet")
+@pytest.mark.anyio
+async def test_successfully_dispatches(
+    capsys: CaptureFixture[str],
+) -> None:
+    cmd = TestCMD(
+        # TODO: stop hardcoding here
+        owner="chia-network",
+        repository="chia-blockchain",
+        per="file",
+        only=Path("util/test_errors.py"),
+        duplicates=2,
+        oses=["linux", "macos-arm"],
+        full_python_matrix=True,
+        open_browser=False,
+    )
+
+    capsys.readouterr()
+    await cmd.run()
+    stdout, stderr = capsys.readouterr()
+
+    assert len(stderr.strip()) == 0
+    for line in stdout.splitlines():
+        match = re.search(r"(?<=\brun api url: )(?P<url>.*)", line)
+        if match is None:
+            continue
+        url = match.group("url")
+        break
+    else:
+        pytest.fail(f"Failed to find run url in: {stdout}")
+
+    token = await get_gh_token()
+    headers = {"Authorization": f"Bearer {token}"}
+
+    async with aiohttp.ClientSession(raise_for_status=True, headers=headers) as client:
+        while True:
+            async with client.get(url) as response:
+                d = await response.json()
+                jobs_url = d["jobs_url"]
+                conclusion = d["conclusion"]
+
+                print("conclusion:", conclusion)
+                if conclusion is None:
+                    await anyio.sleep(5)
+                    continue
+
+                break
+
+        async with client.get(jobs_url) as response:
+            d = await response.json()
+            jobs = d["jobs"]
+
+        by_name = {job["name"]: job for job in jobs}
+
+        assert by_name["Configure matrix"]["conclusion"] == "success"
+        assert by_name["macos-intel"]["conclusion"] == "skipped"
+        assert by_name["windows"]["conclusion"] == "skipped"
+
+        versions = ["3.9", "3.10", "3.11", "3.12"]
+        runs_by_name: dict[str, list[str]] = {name: [] for name in ["ubuntu", "macos-arm"]}
+        for name in by_name:
+            platform, _, rest = name.partition(" / ")
+
+            jobs = runs_by_name.get(platform)
+            if jobs is None:
+                continue
+
+            jobs.append(rest)
+
+        expected = len(versions) * cmd.duplicates
+        print("expected:", expected)
+        print("runs_by_name:", runs_by_name)
+        assert len({expected, *(len(runs) for runs in runs_by_name.values())}) == 1

chia/_tests/cmds/test_farm_cmd.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import re
-from typing import Tuple
 
 import pytest
 from _pytest.capture import CaptureFixture
@@ -18,7 +17,7 @@ from chia.types.aliases import FarmerService, HarvesterService, WalletService
 @pytest.mark.anyio
 async def test_farm_summary_command(
     capsys: CaptureFixture[str],
-    farmer_one_harvester_simulator_wallet: Tuple[
+    farmer_one_harvester_simulator_wallet: tuple[
         HarvesterService,
         FarmerService,
         SimulatorFullNodeService,