chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7__py3-none-any.whl

chia/_tests/harvester/test_harvester_api.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator, Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from chia_rs import ConsensusConstants, FullBlock, ProofOfSpace
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
+
+from chia._tests.conftest import HarvesterFarmerEnvironment
+from chia._tests.plotting.util import get_test_plots
+from chia._tests.util.time_out_assert import time_out_assert
+from chia.harvester.harvester_api import HarvesterAPI
+from chia.plotting.util import PlotInfo
+from chia.protocols import harvester_protocol
+from chia.protocols.harvester_protocol import PoolDifficulty
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.ws_connection import WSChiaConnection
+
+
+@dataclass
+class HarvesterTestEnvironment:
+    """Test environment with real plots loaded for harvester testing."""
+
+    harvester_api: HarvesterAPI
+    plot_info: PlotInfo
+    plot_path: Path
+
+
+@pytest.fixture(scope="function")
+async def harvester_environment(
+    harvester_farmer_environment: HarvesterFarmerEnvironment,
+) -> AsyncGenerator[HarvesterTestEnvironment, None]:
+    """Create a test environment with real plots loaded."""
+    _, _, harvester_service, _, _ = harvester_farmer_environment
+    harvester_api = harvester_service._server.api
+    assert isinstance(harvester_api, HarvesterAPI)
+    test_plots = get_test_plots()
+    assert len(test_plots) > 0, "no test plots available"
+    plot_manager = harvester_api.harvester.plot_manager
+    plot_manager.start_refreshing()
+    await time_out_assert(10, lambda: len(plot_manager.plots) > 0, True)
+    plot_path, plot_info = next(iter(plot_manager.plots.items()))
+    yield HarvesterTestEnvironment(harvester_api, plot_info, plot_path)
+    plot_manager.stop_refreshing()
+
+
+def signage_point_from_block(
+    block: FullBlock, constants: ConsensusConstants
+) -> harvester_protocol.NewSignagePointHarvester2:
+    sp_index = block.reward_chain_block.signage_point_index
+    challenge_hash = block.reward_chain_block.pos_ss_cc_challenge_hash
+    sp_hash = (
+        block.reward_chain_block.reward_chain_sp_vdf.output.get_hash()
+        if block.reward_chain_block.reward_chain_sp_vdf
+        else challenge_hash
+    )
+    return harvester_protocol.NewSignagePointHarvester2(
+        challenge_hash=challenge_hash,
+        difficulty=uint64(constants.DIFFICULTY_STARTING),
+        sub_slot_iters=uint64(constants.SUB_SLOT_ITERS_STARTING),
+        signage_point_index=sp_index,
+        sp_hash=sp_hash,
+        pool_difficulties=[],
+        peak_height=block.height,
+        last_tx_height=block.height,
+    )
+
+
+def create_test_setup(
+    harvester_environment: HarvesterTestEnvironment,
+    default_400_blocks: list[FullBlock],
+    blockchain_constants: ConsensusConstants,
+) -> tuple[HarvesterTestEnvironment, harvester_protocol.NewSignagePointHarvester2, MagicMock]:
+    env = harvester_environment
+    block = default_400_blocks[2]
+    new_challenge = signage_point_from_block(block, blockchain_constants)
+    mock_peer = MagicMock(spec=WSChiaConnection)
+    return env, new_challenge, mock_peer
+
+
+@contextmanager
+def mock_successful_proof(plot_info: PlotInfo) -> Iterator[None]:
+    with patch.object(plot_info.prover, "get_full_proof") as mock_get_proof:
+        mock_proof = MagicMock(spec=ProofOfSpace)
+        mock_get_proof.return_value = mock_proof, None
+        yield
+
+
+def assert_farming_info_sent(mock_peer: MagicMock) -> None:
+    mock_peer.send_message.assert_called()
+    farming_info_calls = [
+        call
+        for call in mock_peer.send_message.call_args_list
+        if call[0][0].type == ProtocolMessageTypes.farming_info.value
+    ]
+    assert len(farming_info_calls) == 1
+
+
+@pytest.mark.anyio
+async def test_new_signage_point_harvester(
+    harvester_environment: HarvesterTestEnvironment,
+    default_400_blocks: list[FullBlock],
+    blockchain_constants: ConsensusConstants,
+) -> None:
+    env, new_challenge, mock_peer = create_test_setup(harvester_environment, default_400_blocks, blockchain_constants)
+    with mock_successful_proof(env.plot_info):
+        await env.harvester_api.new_signage_point_harvester(new_challenge, mock_peer)
+    assert_farming_info_sent(mock_peer)
+
+
+@pytest.mark.anyio
+async def test_new_signage_point_harvester_pool_difficulty(
+    harvester_environment: HarvesterTestEnvironment,
+    default_400_blocks: list[FullBlock],
+    blockchain_constants: ConsensusConstants,
+) -> None:
+    env, new_challenge, mock_peer = create_test_setup(harvester_environment, default_400_blocks, blockchain_constants)
+    pool_puzzle_hash = bytes32(b"pool" + b"0" * 28)
+    env.plot_info.pool_contract_puzzle_hash = pool_puzzle_hash
+    pool_difficulty = PoolDifficulty(
+        pool_contract_puzzle_hash=pool_puzzle_hash,
+        difficulty=uint64(500),
+        sub_slot_iters=uint64(67108864),
+    )
+
+    new_challenge = harvester_protocol.NewSignagePointHarvester2(
+        challenge_hash=new_challenge.challenge_hash,
+        difficulty=new_challenge.difficulty,
+        sub_slot_iters=new_challenge.sub_slot_iters,
+        signage_point_index=new_challenge.signage_point_index,
+        sp_hash=new_challenge.sp_hash,
+        pool_difficulties=[pool_difficulty],  # add pool difficulty
+        peak_height=new_challenge.peak_height,
+        last_tx_height=new_challenge.last_tx_height,
+    )
+
+    with mock_successful_proof(env.plot_info):
+        await env.harvester_api.new_signage_point_harvester(new_challenge, mock_peer)
+
+    assert_farming_info_sent(mock_peer)
+
+
+@pytest.mark.anyio
+async def test_new_signage_point_harvester_prover_error(
+    harvester_environment: HarvesterTestEnvironment,
+    default_400_blocks: list[FullBlock],
+    blockchain_constants: ConsensusConstants,
+) -> None:
+    env, new_challenge, mock_peer = create_test_setup(harvester_environment, default_400_blocks, blockchain_constants)
+    with patch.object(env.plot_info.prover, "get_qualities_for_challenge", side_effect=RuntimeError("test error")):
+        # should not raise exception, should handle error gracefully
+        await env.harvester_api.new_signage_point_harvester(new_challenge, mock_peer)

chia/_tests/plot_sync/test_plot_sync.py

@@ -20,7 +20,9 @@ from chia._tests.plotting.util import get_test_plots
 from chia._tests.util.split_managers import SplitAsyncManager, split_async_manager
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.farmer.farmer import Farmer
+from chia.farmer.farmer_service import FarmerService
 from chia.harvester.harvester import Harvester
+from chia.harvester.harvester_service import HarvesterService
 from chia.plot_sync.delta import Delta, PathListDelta, PlotListDelta
 from chia.plot_sync.receiver import Receiver
 from chia.plot_sync.sender import Sender
@@ -29,7 +31,6 @@ from chia.plotting.manager import PlotManager
 from chia.plotting.util import add_plot_directory, remove_plot_directory
 from chia.protocols.harvester_protocol import Plot
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.server.aliases import FarmerService, HarvesterService
 from chia.simulator.block_tools import BlockTools
 from chia.util.config import create_default_chia_config, lock_and_load_config, save_config
 from chia.util.streamable import _T_Streamable
@@ -194,7 +195,8 @@ class Environment:
             plot = harvester.plot_manager.plots.get(Path(path), None)
             assert plot is not None
             assert plot.prover.get_filename() == delta.valid.additions[path].filename
-            assert plot.prover.get_size() == delta.valid.additions[path].size
+            # TODO: todo_v2_plots support v2 plots
+            assert plot.prover.get_size().size_v1 == delta.valid.additions[path].size
             assert plot.prover.get_id() == delta.valid.additions[path].plot_id
             assert plot.prover.get_compression_level() == delta.valid.additions[path].compression_level
             assert plot.pool_public_key == delta.valid.additions[path].pool_public_key
@@ -255,7 +257,8 @@ class Environment:
             for path, plot_info in plot_manager.plots.items():
                 assert str(path) in receiver.plots()
                 assert plot_info.prover.get_filename() == receiver.plots()[str(path)].filename
-                assert plot_info.prover.get_size() == receiver.plots()[str(path)].size
+                # TODO: todo_v2_plots support v2 plots
+                assert plot_info.prover.get_size().size_v1 == receiver.plots()[str(path)].size
                 assert plot_info.prover.get_id() == receiver.plots()[str(path)].plot_id
                 assert plot_info.prover.get_compression_level() == receiver.plots()[str(path)].compression_level
                 assert plot_info.pool_public_key == receiver.plots()[str(path)].pool_public_key

chia/_tests/plot_sync/test_receiver.py

@@ -7,7 +7,7 @@ import time
 from typing import Any, Callable, Union
 
 import pytest
-from chia_rs import G1Element
+from chia_rs import G1Element, PlotSize
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
@@ -185,8 +185,12 @@ def plot_sync_setup(seeded_random: random.Random) -> tuple[Receiver, list[SyncSt
     # Manually add the plots we want to remove in tests
     receiver._plots = {plot_info.filename: plot_info for plot_info in plot_info_list[0:10]}
     receiver._total_plot_size = sum(plot.file_size for plot in receiver.plots().values())
+    # TODO: todo_v2_plots support v2 plots
     receiver._total_effective_plot_size = int(
-        sum(UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(plot.size)) for plot in receiver.plots().values())
+        sum(
+            UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(PlotSize.make_v1(plot.size)))
+            for plot in receiver.plots().values()
+        )
     )
     sync_steps: list[SyncStepData] = [
         SyncStepData(
@@ -266,7 +270,11 @@ async def test_to_dict(counts_only: bool, seeded_random: random.Random) -> None:
     assert get_list_or_len(plot_sync_dict_1["duplicates"], not counts_only) == 0
     assert plot_sync_dict_1["total_plot_size"] == sum(plot.file_size for plot in receiver.plots().values())
     assert plot_sync_dict_1["total_effective_plot_size"] == int(
-        sum(UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(plot.size)) for plot in receiver.plots().values())
+        # TODO: todo_v2_plots support v2 plots
+        sum(
+            UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(PlotSize.make_v1(plot.size)))
+            for plot in receiver.plots().values()
+        )
     )
     assert plot_sync_dict_1["syncing"] is None
     assert plot_sync_dict_1["last_sync_time"] is None
@@ -312,8 +320,12 @@ async def test_to_dict(counts_only: bool, seeded_random: random.Random) -> None:
     assert get_list_or_len(sync_steps[State.duplicates].args[0], counts_only) == plot_sync_dict_3["duplicates"]
 
     assert plot_sync_dict_3["total_plot_size"] == sum(plot.file_size for plot in receiver.plots().values())
+    # TODO: todo_v2_plots support v2 plots
     assert plot_sync_dict_3["total_effective_plot_size"] == int(
-        sum(UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(plot.size)) for plot in receiver.plots().values())
+        sum(
+            UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(PlotSize.make_v1(plot.size)))
+            for plot in receiver.plots().values()
+        )
     )
     assert plot_sync_dict_3["last_sync_time"] > 0
     assert plot_sync_dict_3["syncing"] is None

chia/_tests/plot_sync/test_sender.py

@@ -14,6 +14,7 @@ from chia.plotting.util import HarvestingMode
 from chia.protocols.harvester_protocol import PlotSyncIdentifier, PlotSyncResponse
 from chia.protocols.outbound_message import NodeType
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.block_tools import BlockTools
 
 
@@ -37,11 +38,11 @@ def test_set_connection_values(bt: BlockTools, seeded_random: random.Random) ->
     # Test invalid NodeType values
     for connection_type in NodeType:
         if connection_type != NodeType.FARMER:
-            pytest.raises(
-                InvalidConnectionTypeError,
-                sender.set_connection,
-                get_dummy_connection(connection_type, farmer_connection.peer_node_id),
-            )
+            with pytest.raises(InvalidConnectionTypeError):
+                dummy_connection: WSChiaConnection = get_dummy_connection(
+                    connection_type, farmer_connection.peer_node_id
+                )  # type: ignore[assignment]
+                sender.set_connection(dummy_connection)
     # Test setting a valid connection works
     sender.set_connection(farmer_connection)  # type:ignore[arg-type]
     assert sender._connection is not None
@@ -74,7 +75,7 @@ def test_set_response(bt: BlockTools) -> None:
 
     def new_response_message(sync_id: int, message_id: int, message_type: ProtocolMessageTypes) -> PlotSyncResponse:
         return PlotSyncResponse(
-            plot_sync_identifier(uint64(sync_id), uint64(message_id)), int16(int(message_type.value)), None
+            plot_sync_identifier(uint64(sync_id), uint64(message_id)), int16(message_type.value), None
         )
 
     response_message = new_response_message(0, 1, ProtocolMessageTypes.plot_sync_start)
@@ -96,7 +97,7 @@ def test_set_response(bt: BlockTools) -> None:
         expected_response.identifier.sync_id,
         expected_response.identifier.message_id,
     )
-    expired_message = PlotSyncResponse(expired_identifier, int16(int(ProtocolMessageTypes.plot_sync_start.value)), None)
+    expired_message = PlotSyncResponse(expired_identifier, int16(ProtocolMessageTypes.plot_sync_start.value), None)
     assert not sender.set_response(expired_message)
     # Test invalid sync-id
     sender._response = new_expected_response(2, 0, ProtocolMessageTypes.plot_sync_start)

chia/_tests/plot_sync/test_sync_simulated.py

@@ -20,16 +20,18 @@ from chia_rs.sized_ints import int16, uint8, uint64
 from chia._tests.plot_sync.util import start_harvester_service
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.farmer.farmer import Farmer
+from chia.farmer.farmer_service import FarmerService
 from chia.harvester.harvester import Harvester
+from chia.harvester.harvester_service import HarvesterService
 from chia.plot_sync.receiver import Receiver
 from chia.plot_sync.sender import Sender
 from chia.plot_sync.util import Constants
 from chia.plotting.manager import PlotManager
+from chia.plotting.prover import V1Prover
 from chia.plotting.util import PlotInfo
 from chia.protocols.harvester_protocol import PlotSyncError, PlotSyncResponse
 from chia.protocols.outbound_message import make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.server.aliases import FarmerService, HarvesterService
 from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.block_tools import BlockTools
 from chia.util.batches import to_batches
@@ -68,17 +70,17 @@ class TestData:
         initial: bool,
     ) -> None:
         for plot_info in loaded:
-            assert plot_info.prover.get_filename() not in self.plots
+            assert Path(plot_info.prover.get_filename()) not in self.plots
         for plot_info in removed:
-            assert plot_info.prover.get_filename() in self.plots
+            assert Path(plot_info.prover.get_filename()) in self.plots
 
         self.invalid = invalid
         self.keys_missing = keys_missing
         self.duplicates = duplicates
 
-        removed_paths: list[Path] = [p.prover.get_filename() for p in removed] if removed is not None else []
-        invalid_dict: dict[Path, int] = {p.prover.get_filename(): 0 for p in self.invalid}
-        keys_missing_set: set[Path] = {p.prover.get_filename() for p in self.keys_missing}
+        removed_paths: list[Path] = [Path(p.prover.get_filename()) for p in removed] if removed is not None else []
+        invalid_dict: dict[Path, int] = {Path(p.prover.get_filename()): 0 for p in self.invalid}
+        keys_missing_set: set[Path] = {Path(p.prover.get_filename()) for p in self.keys_missing}
         duplicates_set: set[str] = {p.prover.get_filename() for p in self.duplicates}
 
         # Inject invalid plots into `PlotManager` of the harvester so that the callback calls below can use them
@@ -122,9 +124,9 @@ class TestData:
         await time_out_assert(60, sync_done)
 
         for plot_info in loaded:
-            self.plots[plot_info.prover.get_filename()] = plot_info
+            self.plots[Path(plot_info.prover.get_filename())] = plot_info
         for plot_info in removed:
-            del self.plots[plot_info.prover.get_filename()]
+            del self.plots[Path(plot_info.prover.get_filename())]
 
     def validate_plot_sync(self) -> None:
         assert len(self.plots) == len(self.plot_sync_receiver.plots())
@@ -140,7 +142,7 @@ class TestData:
             assert plot_info.pool_contract_puzzle_hash == synced_plot.pool_contract_puzzle_hash
             assert plot_info.plot_public_key == synced_plot.plot_public_key
             assert plot_info.file_size == synced_plot.file_size
-            assert uint64(int(plot_info.time_modified)) == synced_plot.time_modified
+            assert uint64(plot_info.time_modified) == synced_plot.time_modified
         for plot_info in self.invalid:
             assert plot_info.prover.get_filename() not in self.plot_sync_receiver.plots()
             assert plot_info.prover.get_filename() in self.plot_sync_receiver.invalid()
@@ -284,7 +286,7 @@ def create_example_plots(count: int, seeded_random: random.Random) -> list[PlotI
 
     return [
         PlotInfo(
-            prover=DiskProver(f"{x}", bytes32.random(seeded_random), 25 + x % 26),
+            prover=V1Prover(DiskProver(f"{x}", bytes32.random(seeded_random), 25 + x % 26)),
             pool_public_key=None,
             pool_contract_puzzle_hash=None,
             plot_public_key=G1Element(),
@@ -416,7 +418,7 @@ async def test_sync_reset_cases(
         # Inject some data into `PlotManager` of the harvester so that we can validate the reset worked and triggered a
         # fresh sync of all available data of the plot manager
         for plot_info in plots[0:10]:
-            test_data.plots[plot_info.prover.get_filename()] = plot_info
+            test_data.plots[Path(plot_info.prover.get_filename())] = plot_info
             plot_manager.plots = test_data.plots
         test_data.invalid = plots[10:20]
         test_data.keys_missing = plots[20:30]
@@ -424,8 +426,8 @@ async def test_sync_reset_cases(
         sender: Sender = test_runner.test_data[0].plot_sync_sender
         started_sync_id: uint64 = uint64(0)
 
-        plot_manager.failed_to_open_filenames = {p.prover.get_filename(): 0 for p in test_data.invalid}
-        plot_manager.no_key_filenames = {p.prover.get_filename() for p in test_data.keys_missing}
+        plot_manager.failed_to_open_filenames = {Path(p.prover.get_filename()): 0 for p in test_data.invalid}
+        plot_manager.no_key_filenames = {Path(p.prover.get_filename()) for p in test_data.keys_missing}
 
         async def wait_for_reset() -> bool:
             assert started_sync_id != 0

chia/_tests/plot_sync/util.py

@@ -11,11 +11,12 @@ from chia_rs.sized_ints import uint16, uint64
 
 from chia._tests.util.split_managers import SplitAsyncManager, split_async_manager
 from chia._tests.util.time_out_assert import time_out_assert
+from chia.farmer.farmer_service import FarmerService
 from chia.harvester.harvester import Harvester
+from chia.harvester.harvester_service import HarvesterService
 from chia.plot_sync.sender import Sender
 from chia.protocols.harvester_protocol import PlotSyncIdentifier
 from chia.protocols.outbound_message import Message, NodeType
-from chia.server.aliases import FarmerService, HarvesterService
 from chia.types.peer_info import PeerInfo, UnresolvedPeerInfo
 
 
@@ -38,7 +39,7 @@ def get_dummy_connection(node_type: NodeType, peer_id: bytes32) -> WSChiaConnect
 
 
 def plot_sync_identifier(current_sync_id: uint64, message_id: uint64) -> PlotSyncIdentifier:
-    return PlotSyncIdentifier(uint64(int(time.time())), current_sync_id, message_id)
+    return PlotSyncIdentifier(uint64(time.time()), current_sync_id, message_id)
 
 
 @contextlib.asynccontextmanager

chia/_tests/plotting/test_plot_manager.py

@@ -13,12 +13,14 @@ from typing import Callable, Optional, cast
 import pytest
 from chia_rs import G1Element
 from chia_rs.sized_ints import uint16, uint32
+from chiapos import DiskProver
 
 from chia._tests.plotting.util import get_test_plots
 from chia._tests.util.misc import boolean_datacases
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.plotting.cache import CURRENT_VERSION, CacheDataV1
 from chia.plotting.manager import Cache, PlotManager
+from chia.plotting.prover import V1Prover
 from chia.plotting.util import (
     PlotInfo,
     PlotRefreshEvents,
@@ -115,10 +117,9 @@ class PlotRefreshTester:
                                 if plot_info.prover.get_filename() == value.prover.get_filename():
                                     values_found += 1
                                     continue
-                        else:
-                            if value in expected_list:
-                                values_found += 1
-                                continue
+                        elif value in expected_list:
+                            values_found += 1
+                            continue
                     if values_found != len(expected_list):
                         log.error(f"{name} invalid: values_found {values_found} expected {len(expected_list)}")
                         return
@@ -507,7 +508,8 @@ async def test_plot_info_caching(environment, bt):
         assert plot_manager.plots[path].prover.get_filename() == plot_info.prover.get_filename()
         assert plot_manager.plots[path].prover.get_id() == plot_info.prover.get_id()
         assert plot_manager.plots[path].prover.get_memo() == plot_info.prover.get_memo()
-        assert plot_manager.plots[path].prover.get_size() == plot_info.prover.get_size()
+        assert plot_manager.plots[path].prover.get_size().size_v1 == plot_info.prover.get_size().size_v1
+        assert plot_manager.plots[path].prover.get_size().size_v2 == plot_info.prover.get_size().size_v2
         assert plot_manager.plots[path].prover.get_compression_level() == plot_info.prover.get_compression_level()
         assert plot_manager.plots[path].pool_public_key == plot_info.pool_public_key
         assert plot_manager.plots[path].pool_contract_puzzle_hash == plot_info.pool_contract_puzzle_hash
@@ -743,6 +745,20 @@ async def test_recursive_plot_scan(environment: Environment) -> None:
     await env.refresh_tester.run(expected_result)
 
 
+@pytest.mark.anyio
+async def test_disk_prover_from_bytes(environment: Environment):
+    env: Environment = environment
+    expected_result = PlotRefreshResult()
+    expected_result.loaded = env.dir_1.plot_info_list()  # type: ignore[assignment]
+    expected_result.processed = len(env.dir_1)
+    add_plot_directory(env.root_path, str(env.dir_1.path))
+    await env.refresh_tester.run(expected_result)
+    _, plot_info = next(iter(env.refresh_tester.plot_manager.plots.items()))
+    recreated_prover = V1Prover(DiskProver.from_bytes(bytes(plot_info.prover)))
+    assert recreated_prover.get_id() == plot_info.prover.get_id()
+    assert recreated_prover.get_filename() == plot_info.prover.get_filename()
+
+
 @boolean_datacases(name="follow_links", false="no_follow", true="follow")
 @pytest.mark.anyio
 async def test_recursive_plot_scan_symlinks(environment: Environment, follow_links: bool) -> None:

chia/_tests/plotting/test_prover.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8
+
+from chia.plotting.prover import PlotVersion, V1Prover, V2Prover, get_prover_from_bytes, get_prover_from_file
+
+
+class TestProver:
+    def test_v2_prover_init_with_nonexistent_file(self) -> None:
+        prover = V2Prover("/nonexistent/path/test.plot2")
+        assert prover.get_version() == PlotVersion.V2
+        assert prover.get_filename() == "/nonexistent/path/test.plot2"
+
+    def test_v2_prover_get_size_raises_error(self) -> None:
+        prover = V2Prover("/nonexistent/path/test.plot2")
+        with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
+            prover.get_size()
+
+    def test_v2_prover_get_memo_raises_error(self) -> None:
+        prover = V2Prover("/nonexistent/path/test.plot2")
+        with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
+            prover.get_memo()
+
+    def test_v2_prover_get_compression_level(self) -> None:
+        prover = V2Prover("/nonexistent/path/test.plot2")
+        assert prover.get_compression_level() == uint8(0)
+
+    def test_v2_prover_get_id_raises_error(self) -> None:
+        prover = V2Prover("/nonexistent/path/test.plot2")
+        with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
+            prover.get_id()
+
+    def test_v2_prover_get_qualities_for_challenge_raises_error(self) -> None:
+        prover = V2Prover("/nonexistent/path/test.plot2")
+        with pytest.raises(
+            AssertionError, match="V2 plot format does not support qualities directly, use partial proofs"
+        ):
+            prover.get_qualities_for_challenge(bytes32(b"1" * 32))
+
+    def test_v2_prover_get_full_proof_raises_error(self) -> None:
+        prover = V2Prover("/nonexistent/path/test.plot2")
+        with pytest.raises(AssertionError, match="V2 plot format require solver to get full proof"):
+            prover.get_full_proof(bytes32(b"1" * 32), 0)
+
+    def test_v2_prover_bytes_raises_error(self) -> None:
+        prover = V2Prover("/nonexistent/path/test.plot2")
+        with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
+            bytes(prover)
+
+    def test_v2_prover_from_bytes_raises_error(self) -> None:
+        with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
+            V2Prover.from_bytes(b"test_data")
+
+    def test_get_prover_from_file(self) -> None:
+        prover = get_prover_from_file("/nonexistent/path/test.plot2")
+        assert prover.get_version() == PlotVersion.V2
+        with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
+            prover.get_size()
+
+    def test_get_prover_from_file_with_plot1_still_works(self) -> None:
+        with tempfile.NamedTemporaryFile(suffix=".plot", delete=False) as f:
+            temp_path = f.name
+        try:
+            with pytest.raises(Exception) as exc_info:
+                get_prover_from_file(temp_path)
+            assert not isinstance(exc_info.value, NotImplementedError)
+        finally:
+            Path(temp_path).unlink()
+
+    def test_unsupported_file_extension_raises_value_error(self) -> None:
+        with pytest.raises(ValueError, match="Unsupported plot file"):
+            get_prover_from_file("/nonexistent/path/test.txt")
+
+
+class TestV1Prover:
+    def test_v1_prover_get_version(self) -> None:
+        """Test that V1Prover.get_version() returns PlotVersion.V1"""
+        mock_disk_prover = MagicMock()
+        prover = V1Prover(mock_disk_prover)
+        assert prover.get_version() == PlotVersion.V1
+
+
+class TestGetProverFromBytes:
+    def test_get_prover_from_bytes_v2_plot(self) -> None:
+        with patch("chia.plotting.prover.V2Prover.from_bytes") as mock_v2_from_bytes:
+            mock_prover = MagicMock()
+            mock_v2_from_bytes.return_value = mock_prover
+            result = get_prover_from_bytes("test.plot2", b"test_data")
+            assert result == mock_prover
+
+    def test_get_prover_from_bytes_v1_plot(self) -> None:
+        with patch("chia.plotting.prover.DiskProver") as mock_disk_prover_class:
+            mock_disk_prover = MagicMock()
+            mock_disk_prover_class.from_bytes.return_value = mock_disk_prover
+            result = get_prover_from_bytes("test.plot", b"test_data")
+            assert isinstance(result, V1Prover)
+
+    def test_get_prover_from_bytes_unsupported_extension(self) -> None:
+        with pytest.raises(ValueError, match="Unsupported plot file"):
+            get_prover_from_bytes("test.txt", b"test_data")

chia/_tests/pools/test_pool_cmdline.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import re
 from dataclasses import dataclass
 from io import StringIO
 from typing import Optional, cast
@@ -9,7 +10,7 @@ import click
 import pytest
 from chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint32, uint64
+from chia_rs.sized_ints import uint16, uint32, uint64
 
 # TODO: update after resolution in https://github.com/pytest-dev/pytest/issues/7469
 from pytest_mock import MockerFixture
@@ -46,7 +47,7 @@ from chia.util.errors import CliRpcConnectionError
 from chia.wallet.util.address_type import AddressType
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.util.wallet_types import WalletType
-from chia.wallet.wallet_request_types import PWStatus
+from chia.wallet.wallet_request_types import GetWallets, PWStatus
 from chia.wallet.wallet_rpc_client import WalletRpcClient
 from chia.wallet.wallet_state_manager import WalletStateManager
 
@@ -153,9 +154,9 @@ async def test_plotnft_cli_create(
         ]
     )
 
-    summaries_response = await wallet_rpc.get_wallets(WalletType.POOLING_WALLET)
-    assert len(summaries_response) == 1
-    wallet_id: int = summaries_response[0]["id"]
+    summaries_response = await wallet_rpc.get_wallets(GetWallets(type=uint16(WalletType.POOLING_WALLET)))
+    assert len(summaries_response.wallets) == 1
+    wallet_id: int = summaries_response.wallets[0].id
 
     await verify_pool_state(wallet_rpc, wallet_id, PoolSingletonState.SELF_POOLING)
 
@@ -484,7 +485,7 @@ async def test_plotnft_cli_join(
     wallet_id = await create_new_plotnft(wallet_environments)
 
     # Test joining the same pool again
-    with pytest.raises(click.ClickException, match="already farming to pool http://pool.example.com"):
+    with pytest.raises(click.ClickException, match=re.escape("already farming to pool http://pool.example.com")):
         await JoinPlotNFTCMD(
             rpc_info=NeedsWalletRPC(
                 client_info=client_info,

chia/_tests/pools/test_pool_puzzles_lifecycle.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import copy
+import re
 from unittest import TestCase
 
 import pytest
@@ -31,6 +32,7 @@ from chia.pools.pool_wallet_info import PoolState
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.coin_spend import make_spend
+from chia.util.errors import Err
 from chia.wallet.puzzles import singleton_top_layer
 from chia.wallet.puzzles.p2_conditions import puzzle_for_conditions
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
@@ -242,7 +244,8 @@ class TestPoolPuzzles(TestCase):
         )
         # Spend it and hope it fails!
         with pytest.raises(
-            BadSpendBundleError, match="condition validation failure Err.ASSERT_ANNOUNCE_CONSUMED_FAILED"
+            BadSpendBundleError,
+            match=re.escape(f"condition validation failure {Err.ASSERT_ANNOUNCE_CONSUMED_FAILED!s}"),
         ):
             coin_db.update_coin_store_for_spend_bundle(
                 SpendBundle([singleton_coinsol], G2Element()), time, DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM
@@ -269,7 +272,8 @@ class TestPoolPuzzles(TestCase):
         )
         # Spend it and hope it fails!
         with pytest.raises(
-            BadSpendBundleError, match="condition validation failure Err.ASSERT_ANNOUNCE_CONSUMED_FAILED"
+            BadSpendBundleError,
+            match=re.escape(f"condition validation failure {Err.ASSERT_ANNOUNCE_CONSUMED_FAILED!s}"),
         ):
             coin_db.update_coin_store_for_spend_bundle(
                 SpendBundle([singleton_coinsol, bad_coinsol], G2Element()), time, DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM
@@ -320,7 +324,10 @@ class TestPoolPuzzles(TestCase):
             (data + singleton.name() + DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA),
         )
         # Spend it and hope it fails!
-        with pytest.raises(BadSpendBundleError, match="condition validation failure Err.ASSERT_HEIGHT_RELATIVE_FAILED"):
+        with pytest.raises(
+            BadSpendBundleError,
+            match=re.escape(f"condition validation failure {Err.ASSERT_HEIGHT_RELATIVE_FAILED!s}"),
+        ):
             coin_db.update_coin_store_for_spend_bundle(
                 SpendBundle([return_coinsol], sig), time, DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM
             )