chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/cmds/test_cmds_util.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from chia._tests.util.misc import RecordingWebServer
+from chia.cmds.cmds_util import get_any_service_client
+from chia.rpc.rpc_client import ResponseFailureError, RpcClient
+
+
+@pytest.mark.anyio
+async def test_get_any_service_client_works_without_ssl(
+    root_path_populated_with_config: Path,
+    recording_web_server: RecordingWebServer,
+) -> None:
+    expected_result = {"success": True, "keepy": "uppy"}
+
+    async with get_any_service_client(
+        client_type=RpcClient,
+        rpc_port=recording_web_server.web_server.listen_port,
+        root_path=root_path_populated_with_config,
+        use_ssl=False,
+    ) as [rpc_client, _]:
+        result = await rpc_client.fetch(path="", request_json={"response": expected_result})
+
+    assert result == expected_result
+
+
+@pytest.mark.anyio
+async def test_failure_output_no_traceback(
+    root_path_populated_with_config: Path,
+    recording_web_server: RecordingWebServer,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    expected_response = {"success": False, "magic": "statue"}
+
+    async with get_any_service_client(
+        client_type=RpcClient,
+        rpc_port=recording_web_server.web_server.listen_port,
+        root_path=root_path_populated_with_config,
+        use_ssl=False,
+    ) as (client, _):
+        await client.fetch(path="/table", request_json={"response": expected_response})
+
+    out, _err = capsys.readouterr()
+
+    assert "ResponseFailureError" not in out
+    assert "Traceback:" not in out
+    assert json.dumps(expected_response) in out
+
+
+@pytest.mark.anyio
+async def test_failure_output_with_traceback(
+    root_path_populated_with_config: Path,
+    recording_web_server: RecordingWebServer,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    sample_traceback = "this\nthat"
+    sample_traceback_json = json.dumps(sample_traceback)
+    expected_response = {"success": False, "traceback": sample_traceback}
+
+    async with get_any_service_client(
+        client_type=RpcClient,
+        rpc_port=recording_web_server.web_server.listen_port,
+        root_path=root_path_populated_with_config,
+        use_ssl=False,
+    ) as (client, _):
+        await client.fetch(path="/table", request_json={"response": expected_response})
+
+    out, _err = capsys.readouterr()
+    assert sample_traceback_json not in out
+    assert sample_traceback in out
+
+
+@pytest.mark.anyio
+async def test_failure_output_no_consumption(
+    root_path_populated_with_config: Path,
+    recording_web_server: RecordingWebServer,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    expected_response = {"success": False, "magic": "xylophone"}
+
+    with pytest.raises(ResponseFailureError) as exception_info:
+        async with get_any_service_client(
+            client_type=RpcClient,
+            rpc_port=recording_web_server.web_server.listen_port,
+            root_path=root_path_populated_with_config,
+            use_ssl=False,
+            consume_errors=False,
+        ) as (client, _):
+            await client.fetch(path="/table", request_json={"response": expected_response})
+
+    assert exception_info.value.response == expected_response
+
+    assert capsys.readouterr() == ("", "")

chia/_tests/cmds/test_daemon.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any, Optional
+
+import pytest
+from _pytest.capture import CaptureFixture
+from click.testing import CliRunner
+from pytest_mock import MockerFixture
+
+from chia.cmds.chia import cli
+from chia.cmds.start_funcs import create_start_daemon_connection, launch_start_daemon
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("skip_keyring", [False, True])
+@pytest.mark.parametrize("unlock_keyring", [False, True])
+async def test_daemon(
+    skip_keyring: bool, unlock_keyring: bool, mocker: MockerFixture, capsys: CaptureFixture[str]
+) -> None:
+    class DummyConnection:
+        @staticmethod
+        async def is_keyring_locked() -> bool:
+            return unlock_keyring
+
+        @staticmethod
+        async def unlock_keyring(_passphrase: str) -> bool:
+            return True
+
+    async def connect_to_daemon_and_validate(_root_path: Path, _config: dict[str, Any]) -> DummyConnection:
+        return DummyConnection()
+
+    class DummyKeychain:
+        @staticmethod
+        def get_cached_master_passphrase() -> Optional[str]:
+            return None
+
+    def get_current_passphrase() -> Optional[str]:
+        return "a-passphrase"
+
+    mocker.patch("chia.cmds.start_funcs.connect_to_daemon_and_validate", side_effect=connect_to_daemon_and_validate)
+    mocker.patch("chia.cmds.start_funcs.Keychain", new=DummyKeychain)
+    mocker.patch("chia.cmds.start_funcs.get_current_passphrase", side_effect=get_current_passphrase)
+
+    daemon = await create_start_daemon_connection(Path("/path-not-exist"), {}, skip_keyring=skip_keyring)
+    assert daemon is not None
+    captured = capsys.readouterr()
+    assert captured.err == ""
+    if skip_keyring:
+        assert captured.out.endswith("Skipping to unlock keyring\n")
+    else:
+        assert not captured.out.endswith("Skipping to unlock keyring\n")
+
+
+@pytest.mark.anyio
+def test_launch_start_daemon(tmp_path: Path) -> None:
+    sys.argv[0] = "not-exist"
+    with pytest.raises(FileNotFoundError):
+        launch_start_daemon(tmp_path)
+
+    helper: Path = Path(sys.executable)
+    sys.argv[0] = str(helper.parent) + "/chia"
+    process = launch_start_daemon(tmp_path)
+    assert process is not None
+    process.kill()
+    process.wait()
+
+
+def test_start_daemon(tmp_path: Path, empty_keyring: Any, mocker: MockerFixture) -> None:
+    class DummyDaemon:
+        @staticmethod
+        async def close() -> None:
+            return None
+
+    async def create_start_daemon_connection_dummy(
+        root_path: Path, config: dict[str, Any], *, skip_keyring: bool
+    ) -> DummyDaemon:
+        return DummyDaemon()
+
+    mocker.patch(
+        "chia.cmds.start_funcs.create_start_daemon_connection", side_effect=create_start_daemon_connection_dummy
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(
+        cli,
+        ["--root-path", str(tmp_path), "init"],
+    )
+    assert result.exit_code == 0
+    result = runner.invoke(cli, ["--root-path", str(tmp_path), "start", "daemon", "-s"])
+    assert result.exit_code == 0

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

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import re
+
+import pytest
+from _pytest.capture import CaptureFixture
+
+from chia._tests.util.time_out_assert import time_out_assert
+from chia.cmds.farm_funcs import summary
+from chia.farmer.farmer import Farmer
+from chia.harvester.harvester import Harvester
+from chia.simulator.block_tools import BlockTools
+from chia.simulator.start_simulator import SimulatorFullNodeService
+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[
+        HarvesterService,
+        FarmerService,
+        SimulatorFullNodeService,
+        WalletService,
+        BlockTools,
+    ],
+) -> None:
+    harvester_service, farmer_service, full_node_service, wallet_service, bt = farmer_one_harvester_simulator_wallet
+    harvester: Harvester = harvester_service._node
+    farmer: Farmer = farmer_service._node
+
+    async def receiver_available() -> bool:
+        return harvester.server.node_id in farmer.plot_sync_receivers
+
+    # Wait for the receiver to show up
+    await time_out_assert(20, receiver_available)
+    receiver = farmer.plot_sync_receivers[harvester.server.node_id]
+    # And wait until the first sync from the harvester to the farmer is done
+    await time_out_assert(20, receiver.initial_sync, False)
+
+    assert full_node_service.rpc_server and full_node_service.rpc_server.webserver
+    assert wallet_service.rpc_server and wallet_service.rpc_server.webserver
+    assert farmer_service.rpc_server and farmer_service.rpc_server.webserver
+
+    full_node_rpc_port = full_node_service.rpc_server.webserver.listen_port
+    wallet_rpc_port = wallet_service.rpc_server.webserver.listen_port
+    farmer_rpc_port = farmer_service.rpc_server.webserver.listen_port
+
+    await summary(full_node_rpc_port, wallet_rpc_port, None, farmer_rpc_port, bt.root_path)
+
+    captured = capsys.readouterr()
+    match = re.search(r"^.+(Farming status:.+)$", captured.out, re.DOTALL)
+    assert match is not None
+    lines = match.group(1).split("\n")
+
+    assert lines[0] == "Farming status: Not synced or not connected to peers"
+    assert "Total chia farmed:" in lines[1]
+    assert "User transaction fees:" in lines[2]
+    assert "Block rewards:" in lines[3]
+    assert "Last height farmed:" in lines[4]
+    assert lines[5] == "Local Harvester"
+    assert "e (effective)" in lines[6]
+    assert "Plot count for all harvesters:" in lines[7]
+    assert "e (effective)" in lines[8]
+    assert "Estimated network space:" in lines[9]
+    assert "Expected time to win:" in lines[10]

chia/_tests/cmds/test_show.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+from chia._tests.cmds.cmd_test_utils import TestFullNodeRpcClient, TestRpcClients, run_cli_command_and_assert
+from chia._tests.cmds.testing_classes import hash_to_height, height_hash
+from chia._tests.util.test_full_block_utils import get_foliage, get_reward_chain_block, get_transactions_info, vdf_proof
+from chia.types.blockchain_format.foliage import FoliageTransactionBlock
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.full_block import FullBlock
+from chia.util.ints import uint32, uint64
+
+
+@dataclass
+class ShowFullNodeRpcClient(TestFullNodeRpcClient):
+    async def get_fee_estimate(self, target_times: Optional[list[int]], cost: Optional[int]) -> dict[str, Any]:
+        self.add_to_log("get_fee_estimate", (target_times, cost))
+        response: dict[str, Any] = {
+            "current_fee_rate": 0,
+            "estimates": [0, 0, 0],
+            "fee_rate_last_block": 30769.681426718744,
+            "fees_last_block": 500000000000,
+            "full_node_synced": True,
+            "last_block_cost": 16249762,
+            "last_peak_timestamp": 1688858763,
+            "last_tx_block_height": 11,
+            "mempool_fees": 0,
+            "mempool_max_size": 0,
+            "mempool_size": 0,
+            "node_time_utc": 1689187617,
+            "num_spends": 0,
+            "peak_height": 11,
+            "success": True,
+            "target_times": target_times,
+        }
+        return response
+
+    async def get_block(self, header_hash: bytes32) -> Optional[FullBlock]:
+        # we return a block with the height matching the header hash
+        self.add_to_log("get_block", (header_hash,))
+        height = hash_to_height(header_hash)
+        foliage = None
+        for foliage in get_foliage():
+            break
+        assert foliage is not None
+        r_chain_block = None
+        for r_chain_block in get_reward_chain_block(height=uint32(height)):
+            break
+        assert r_chain_block is not None
+        foliage_tx_block = FoliageTransactionBlock(
+            prev_transaction_block_hash=height_hash(height - 1),
+            timestamp=uint64(100400000),
+            filter_hash=bytes32([2] * 32),
+            additions_root=bytes32([3] * 32),
+            removals_root=bytes32([4] * 32),
+            transactions_info_hash=bytes32([5] * 32),
+        )
+        tx_info = None
+        for tx_info in get_transactions_info(height=uint32(height), foliage_transaction_block=foliage_tx_block):
+            break
+        assert tx_info is not None
+        full_block = FullBlock(
+            finished_sub_slots=[],
+            reward_chain_block=r_chain_block,
+            challenge_chain_sp_proof=None,
+            challenge_chain_ip_proof=vdf_proof(),
+            reward_chain_sp_proof=None,
+            reward_chain_ip_proof=vdf_proof(),
+            infused_challenge_chain_ip_proof=None,
+            foliage=foliage,
+            foliage_transaction_block=foliage_tx_block,
+            transactions_info=tx_info,
+            transactions_generator=SerializedProgram.from_bytes(bytes.fromhex("ff01820539")),
+            transactions_generator_ref_list=[],
+        )
+        return full_block
+
+
+RPC_CLIENT_TO_USE = ShowFullNodeRpcClient()
+
+
+def test_chia_show(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
+    test_rpc_clients, root_dir = get_test_cli_clients
+    # set RPC Client
+    test_rpc_clients.full_node_rpc_client = RPC_CLIENT_TO_USE
+    # get output with all options
+    command_args = [
+        "show",
+        "-s",
+        "-f",
+        "--block-header-hash-by-height",
+        "10",
+        "-b0x000000000000000000000000000000000000000000000000000000000000000b",
+    ]
+    # these are various things that should be in the output
+    assert_list = [
+        "Current Blockchain Status: Full Node Synced",
+        "Estimated network space: 25.647 EiB",
+        "Block fees: 500000000000 mojos",
+        "Fee rate:    3.077e+04 mojos per CLVM cost",
+        f"Tx Filter Hash         {bytes32([2] * 32).hex()}",
+        "Weight                 10000",
+        "Is a Transaction Block?True",
+    ]
+    run_cli_command_and_assert(capsys, root_dir, command_args, assert_list)
+    expected_calls: dict[str, Optional[list[tuple[Any, ...]]]] = {  # name of rpc: (args)
+        "get_blockchain_state": None,
+        "get_block_record": [(height_hash(height),) for height in [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 11, 10]],
+        "get_block_record_by_height": [(10,)],
+        "get_fee_estimate": [([60, 120, 300], 1)],
+        "get_block": [(height_hash(11),)],
+    }  # these RPC's should be called with these variables.
+    test_rpc_clients.full_node_rpc_client.check_log(expected_calls)