chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/_tests/plot_sync/test_plot_sync.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import functools
+from collections.abc import AsyncIterator
 from dataclasses import dataclass, field, replace
 from pathlib import Path
 from shutil import copy
-from typing import Any, AsyncIterator, Callable, List, Optional, Tuple
+from typing import Any, Callable, Optional
 
 import pytest
 from chia_rs import G1Element
@@ -43,7 +44,7 @@ def synced(sender: Sender, receiver: Receiver, previous_last_sync_id: int) -> bo
     )
 
 
-def assert_path_list_matches(expected_list: List[str], actual_list: List[str]) -> None:
+def assert_path_list_matches(expected_list: list[str], actual_list: list[str]) -> None:
     assert len(expected_list) == len(actual_list)
     for item in expected_list:
         assert str(item) in actual_list
@@ -61,12 +62,12 @@ class ExpectedResult:
     duplicates_delta: PathListDelta = field(default_factory=PathListDelta)
     callback_passed: bool = False
 
-    def add_valid(self, list_plots: List[MockPlotInfo]) -> None:
+    def add_valid(self, list_plots: list[MockPlotInfo]) -> None:
         def create_mock_plot(info: MockPlotInfo) -> Plot:
             return Plot(
                 info.prover.get_filename(),
                 uint8(0),
-                bytes32(b"\x00" * 32),
+                bytes32.zeros,
                 None,
                 None,
                 G1Element(),
@@ -78,31 +79,31 @@ class ExpectedResult:
         self.valid_count += len(list_plots)
         self.valid_delta.additions.update({x.prover.get_filename(): create_mock_plot(x) for x in list_plots})
 
-    def remove_valid(self, list_paths: List[Path]) -> None:
+    def remove_valid(self, list_paths: list[Path]) -> None:
         self.valid_count -= len(list_paths)
         self.valid_delta.removals += [str(x) for x in list_paths]
 
-    def add_invalid(self, list_paths: List[Path]) -> None:
+    def add_invalid(self, list_paths: list[Path]) -> None:
         self.invalid_count += len(list_paths)
         self.invalid_delta.additions += [str(x) for x in list_paths]
 
-    def remove_invalid(self, list_paths: List[Path]) -> None:
+    def remove_invalid(self, list_paths: list[Path]) -> None:
         self.invalid_count -= len(list_paths)
         self.invalid_delta.removals += [str(x) for x in list_paths]
 
-    def add_keys_missing(self, list_paths: List[Path]) -> None:
+    def add_keys_missing(self, list_paths: list[Path]) -> None:
         self.keys_missing_count += len(list_paths)
         self.keys_missing_delta.additions += [str(x) for x in list_paths]
 
-    def remove_keys_missing(self, list_paths: List[Path]) -> None:
+    def remove_keys_missing(self, list_paths: list[Path]) -> None:
         self.keys_missing_count -= len(list_paths)
         self.keys_missing_delta.removals += [str(x) for x in list_paths]
 
-    def add_duplicates(self, list_paths: List[Path]) -> None:
+    def add_duplicates(self, list_paths: list[Path]) -> None:
         self.duplicates_count += len(list_paths)
         self.duplicates_delta.additions += [str(x) for x in list_paths]
 
-    def remove_duplicates(self, list_paths: List[Path]) -> None:
+    def remove_duplicates(self, list_paths: list[Path]) -> None:
         self.duplicates_count -= len(list_paths)
         self.duplicates_delta.removals += [str(x) for x in list_paths]
 
@@ -110,9 +111,9 @@ class ExpectedResult:
 @dataclass
 class Environment:
     root_path: Path
-    harvester_services: List[HarvesterService]
+    harvester_services: list[HarvesterService]
     farmer_service: FarmerService
-    harvesters: List[Harvester]
+    harvesters: list[Harvester]
     farmer: Farmer
     dir_1: Directory
     dir_2: Directory
@@ -121,9 +122,9 @@ class Environment:
     dir_invalid: Directory
     dir_keys_missing: Directory
     dir_duplicates: Directory
-    expected: List[ExpectedResult]
+    expected: list[ExpectedResult]
     split_farmer_service_manager: SplitAsyncManager[FarmerService]
-    split_harvester_managers: List[SplitAsyncManager[Harvester]]
+    split_harvester_managers: list[SplitAsyncManager[Harvester]]
 
     def get_harvester(self, peer_id: bytes32) -> Optional[Harvester]:
         for harvester in self.harvesters:
@@ -218,7 +219,7 @@ class Environment:
     async def run_sync_test(self) -> None:
         plot_manager: PlotManager
         assert len(self.harvesters) == len(self.expected)
-        last_sync_ids: List[uint64] = []
+        last_sync_ids: list[uint64] = []
         # Run the test in two steps, first trigger the refresh on both harvesters
         for harvester in self.harvesters:
             plot_manager = harvester.plot_manager
@@ -279,16 +280,16 @@ class Environment:
 @pytest.fixture(scope="function")
 async def environment(
     tmp_path: Path,
-    farmer_two_harvester_not_started: Tuple[List[HarvesterService], FarmerService, BlockTools],
+    farmer_two_harvester_not_started: tuple[list[HarvesterService], FarmerService, BlockTools],
 ) -> AsyncIterator[Environment]:
-    def new_test_dir(name: str, plot_list: List[Path]) -> Directory:
+    def new_test_dir(name: str, plot_list: list[Path]) -> Directory:
         return Directory(tmp_path / "plots" / name, plot_list)
 
-    plots: List[Path] = get_test_plots()
-    plots_invalid: List[Path] = get_test_plots()[0:3]
-    plots_keys_missing: List[Path] = get_test_plots("not_in_keychain")
+    plots: list[Path] = get_test_plots()
+    plots_invalid: list[Path] = get_test_plots()[0:3]
+    plots_keys_missing: list[Path] = get_test_plots("not_in_keychain")
     # Create 4 directories where: dir_n contains n plots
-    directories: List[Directory] = []
+    directories: list[Directory] = []
     offset: int = 0
     while len(directories) < 4:
         dir_number = len(directories) + 1
@@ -535,7 +536,7 @@ async def test_farmer_restart(environment: Environment) -> None:
     env: Environment = environment
     # Load all directories for both harvesters
     await add_and_validate_all_directories(env)
-    last_sync_ids: List[uint64] = []
+    last_sync_ids: list[uint64] = []
     for i in range(0, len(env.harvesters)):
         last_sync_ids.append(env.harvesters[i].plot_sync_sender._last_sync_id)
     # Stop the farmer and make sure both receivers get dropped and refreshing gets stopped on the harvesters
@@ -569,7 +570,7 @@ async def test_farmer_restart(environment: Environment) -> None:
 
 @pytest.mark.anyio
 async def test_sync_start_and_disconnect_while_sync_is_active(
-    farmer_one_harvester: Tuple[List[HarvesterService], FarmerService, BlockTools]
+    farmer_one_harvester: tuple[list[HarvesterService], FarmerService, BlockTools],
 ) -> None:
     harvesters, farmer_service, _ = farmer_one_harvester
     harvester_service = harvesters[0]

chia/_tests/plot_sync/test_receiver.py

@@ -4,7 +4,7 @@ import dataclasses
 import logging
 import random
 import time
-from typing import Any, Callable, List, Tuple, Type, Union
+from typing import Any, Callable, Union
 
 import pytest
 from chia_rs import G1Element
@@ -57,7 +57,7 @@ class SyncStepData:
     args: Any
 
     def __init__(
-        self, state: State, function: Callable[[_T_Streamable], Any], payload_type: Type[_T_Streamable], *args: Any
+        self, state: State, function: Callable[[_T_Streamable], Any], payload_type: type[_T_Streamable], *args: Any
     ) -> None:
         self.state = state
         self.function = function
@@ -89,7 +89,7 @@ def assert_error_response(plot_sync: Receiver, error_code: ErrorCodes) -> None:
     assert response.error.code == error_code.value
 
 
-def pre_function_validate(receiver: Receiver, data: Union[List[Plot], List[str]], expected_state: State) -> None:
+def pre_function_validate(receiver: Receiver, data: Union[list[Plot], list[str]], expected_state: State) -> None:
     if expected_state == State.loaded:
         for plot_info in data:
             assert type(plot_info) is Plot
@@ -108,7 +108,7 @@ def pre_function_validate(receiver: Receiver, data: Union[List[Plot], List[str]]
             assert path not in receiver.duplicates()
 
 
-def post_function_validate(receiver: Receiver, data: Union[List[Plot], List[str]], expected_state: State) -> None:
+def post_function_validate(receiver: Receiver, data: Union[list[Plot], list[str]], expected_state: State) -> None:
     if expected_state == State.loaded:
         for plot_info in data:
             assert type(plot_info) is Plot
@@ -132,7 +132,7 @@ async def run_sync_step(receiver: Receiver, sync_step: SyncStepData) -> None:
     assert receiver.current_sync().state == sync_step.state
     last_sync_time_before = receiver._last_sync.time_done
     # For the list types invoke the trigger function in batches
-    if sync_step.payload_type == PlotSyncPlotList or sync_step.payload_type == PlotSyncPathList:
+    if sync_step.payload_type in {PlotSyncPlotList, PlotSyncPathList}:
         step_data, _ = sync_step.args
         assert len(step_data) == 10
         # Invoke batches of: 1, 2, 3, 4 items and validate the data against plot store before and after
@@ -161,7 +161,7 @@ async def run_sync_step(receiver: Receiver, sync_step: SyncStepData) -> None:
         assert receiver._last_sync.time_done == last_sync_time_before
 
 
-def plot_sync_setup(seeded_random: random.Random) -> Tuple[Receiver, List[SyncStepData]]:
+def plot_sync_setup(seeded_random: random.Random) -> tuple[Receiver, list[SyncStepData]]:
     harvester_connection = get_dummy_connection(NodeType.HARVESTER, bytes32.random(seeded_random))
     receiver = Receiver(harvester_connection, dummy_callback)  # type:ignore[arg-type]
 
@@ -188,7 +188,7 @@ def plot_sync_setup(seeded_random: random.Random) -> Tuple[Receiver, List[SyncSt
     receiver._total_effective_plot_size = int(
         sum(UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(plot.size)) for plot in receiver.plots().values())
     )
-    sync_steps: List[SyncStepData] = [
+    sync_steps: list[SyncStepData] = [
         SyncStepData(
             State.idle,
             receiver.sync_started,
@@ -223,7 +223,7 @@ def test_default_values(seeded_random: random.Random) -> None:
 
 @pytest.mark.anyio
 async def test_reset(seeded_random: random.Random) -> None:
-    receiver, sync_steps = plot_sync_setup(seeded_random=seeded_random)
+    receiver, _sync_steps = plot_sync_setup(seeded_random=seeded_random)
     connection_before = receiver.connection()
     # Assign some dummy values
     receiver._current_sync.state = State.done
@@ -289,7 +289,7 @@ async def test_to_dict(counts_only: bool, seeded_random: random.Random) -> None:
     for state in State:
         await run_sync_step(receiver, sync_steps[state])
 
-        if state != State.idle and state != State.removed and state != State.done:
+        if state not in {State.idle, State.removed, State.done}:
             expected_plot_files_processed += len(sync_steps[state].args[0])
 
         sync_data = receiver.to_dict()["syncing"]

chia/_tests/plot_sync/test_sender.py

@@ -45,7 +45,7 @@ def test_set_connection_values(bt: BlockTools, seeded_random: random.Random) ->
     # Test setting a valid connection works
     sender.set_connection(farmer_connection)  # type:ignore[arg-type]
     assert sender._connection is not None
-    assert sender._connection == farmer_connection  # type: ignore[comparison-overlap]
+    assert id(sender._connection) == id(farmer_connection)
 
 
 @pytest.mark.anyio

chia/_tests/plot_sync/test_sync_simulated.py

@@ -6,10 +6,11 @@ import functools
 import logging
 import random
 import time
+from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Any, AsyncIterator, Dict, List, Optional, Set, Tuple
+from typing import Any, Optional
 
 import pytest
 from chia_rs import G1Element
@@ -51,19 +52,19 @@ class TestData:
     plot_sync_sender: Sender
     plot_sync_receiver: Receiver
     event_loop: asyncio.AbstractEventLoop
-    plots: Dict[Path, PlotInfo] = field(default_factory=dict)
-    invalid: List[PlotInfo] = field(default_factory=list)
-    keys_missing: List[PlotInfo] = field(default_factory=list)
-    duplicates: List[PlotInfo] = field(default_factory=list)
+    plots: dict[Path, PlotInfo] = field(default_factory=dict)
+    invalid: list[PlotInfo] = field(default_factory=list)
+    keys_missing: list[PlotInfo] = field(default_factory=list)
+    duplicates: list[PlotInfo] = field(default_factory=list)
 
     async def run(
         self,
         *,
-        loaded: List[PlotInfo],
-        removed: List[PlotInfo],
-        invalid: List[PlotInfo],
-        keys_missing: List[PlotInfo],
-        duplicates: List[PlotInfo],
+        loaded: list[PlotInfo],
+        removed: list[PlotInfo],
+        invalid: list[PlotInfo],
+        keys_missing: list[PlotInfo],
+        duplicates: list[PlotInfo],
         initial: bool,
     ) -> None:
         for plot_info in loaded:
@@ -75,10 +76,10 @@ class TestData:
         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}
-        duplicates_set: Set[str] = {p.prover.get_filename() for p in self.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}
+        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
         # to sync them to the farmer.
@@ -158,10 +159,10 @@ class TestData:
 
 @dataclass
 class TestRunner:
-    test_data: List[TestData]
+    test_data: list[TestData]
 
     def __init__(
-        self, harvesters: List[Harvester], farmer: Farmer, event_loop: asyncio.events.AbstractEventLoop
+        self, harvesters: list[Harvester], farmer: Farmer, event_loop: asyncio.events.AbstractEventLoop
     ) -> None:
         self.test_data = []
         for harvester in harvesters:
@@ -179,11 +180,11 @@ class TestRunner:
         self,
         index: int,
         *,
-        loaded: List[PlotInfo],
-        removed: List[PlotInfo],
-        invalid: List[PlotInfo],
-        keys_missing: List[PlotInfo],
-        duplicates: List[PlotInfo],
+        loaded: list[PlotInfo],
+        removed: list[PlotInfo],
+        invalid: list[PlotInfo],
+        keys_missing: list[PlotInfo],
+        duplicates: list[PlotInfo],
         initial: bool,
     ) -> None:
         await self.test_data[index].run(
@@ -241,7 +242,7 @@ async def _testable_process(
 
 @contextlib.asynccontextmanager
 async def create_test_runner(
-    harvester_services: List[HarvesterService],
+    harvester_services: list[HarvesterService],
     farmer_service: FarmerService,
     event_loop: asyncio.events.AbstractEventLoop,
 ) -> AsyncIterator[TestRunner]:
@@ -262,7 +263,7 @@ async def create_test_runner(
             yield TestRunner(harvesters, farmer, event_loop)
 
 
-def create_example_plots(count: int, seeded_random: random.Random) -> List[PlotInfo]:
+def create_example_plots(count: int, seeded_random: random.Random) -> list[PlotInfo]:
     @dataclass
     class DiskProver:
         file_name: str
@@ -296,7 +297,7 @@ def create_example_plots(count: int, seeded_random: random.Random) -> List[PlotI
 
 @pytest.mark.anyio
 async def test_sync_simulated(
-    farmer_three_harvester_not_started: Tuple[List[HarvesterService], FarmerService, BlockTools],
+    farmer_three_harvester_not_started: tuple[list[HarvesterService], FarmerService, BlockTools],
     event_loop: asyncio.events.AbstractEventLoop,
     seeded_random: random.Random,
 ) -> None:
@@ -376,7 +377,7 @@ async def test_sync_simulated(
 )
 @pytest.mark.anyio
 async def test_farmer_error_simulation(
-    farmer_one_harvester_not_started: Tuple[List[HarvesterService], FarmerService, BlockTools],
+    farmer_one_harvester_not_started: tuple[list[HarvesterService], FarmerService, BlockTools],
     event_loop: asyncio.events.AbstractEventLoop,
     simulate_error: ErrorSimulation,
     seeded_random: random.Random,
@@ -402,7 +403,7 @@ async def test_farmer_error_simulation(
 @pytest.mark.parametrize("simulate_error", [ErrorSimulation.NonRecoverableError, ErrorSimulation.NotConnected])
 @pytest.mark.anyio
 async def test_sync_reset_cases(
-    farmer_one_harvester_not_started: Tuple[List[HarvesterService], FarmerService, BlockTools],
+    farmer_one_harvester_not_started: tuple[list[HarvesterService], FarmerService, BlockTools],
     event_loop: asyncio.events.AbstractEventLoop,
     simulate_error: ErrorSimulation,
     seeded_random: random.Random,

chia/_tests/plot_sync/util.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import contextlib
 import time
+from collections.abc import AsyncIterator
 from dataclasses import dataclass
-from typing import AsyncIterator, Optional
+from typing import Optional
 
 from chia._tests.util.split_managers import SplitAsyncManager, split_async_manager
 from chia._tests.util.time_out_assert import time_out_assert

chia/_tests/plotting/test_plot_manager.py

@@ -3,16 +3,18 @@ from __future__ import annotations
 import logging
 import sys
 import time
+from collections.abc import Iterator
 from dataclasses import dataclass, replace
 from os import unlink
 from pathlib import Path
 from shutil import copy, move
-from typing import Callable, Iterator, List, Optional, cast
+from typing import Callable, Optional, cast
 
 import pytest
 from chia_rs import G1Element
 
 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
@@ -32,6 +34,9 @@ from chia.util.streamable import VersionedBlob
 
 log = logging.getLogger(__name__)
 
+# These tests are not dependent on consensus rules
+pytestmark = [pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")]
+
 
 @dataclass
 class MockDiskProver:
@@ -48,9 +53,9 @@ class MockPlotInfo:
 
 class Directory:
     path: Path
-    plots: List[Path]
+    plots: list[Path]
 
-    def __init__(self, path: Path, plots_origin: List[Path]):
+    def __init__(self, path: Path, plots_origin: list[Path]):
         self.path = path
         path.mkdir(parents=True, exist_ok=True)
         # Drop the existing files in the test directories
@@ -66,10 +71,10 @@ class Directory:
     def __len__(self):
         return len(self.plots)
 
-    def plot_info_list(self) -> List[MockPlotInfo]:
+    def plot_info_list(self) -> list[MockPlotInfo]:
         return [MockPlotInfo(MockDiskProver(str(x))) for x in self.plots]
 
-    def path_list(self) -> List[Path]:
+    def path_list(self) -> list[Path]:
         return self.plots
 
     def drop(self, path: Path):
@@ -149,7 +154,7 @@ class Environment:
 def environment(tmp_path, bt) -> Iterator[Environment]:
     dir_1_count: int = 7
     dir_2_count: int = 3
-    plots: List[Path] = get_test_plots()
+    plots: list[Path] = get_test_plots()
     assert len(plots) >= dir_1_count + dir_2_count
 
     dir_1: Directory = Directory(tmp_path / "plots" / "1", plots[0:dir_1_count])
@@ -180,14 +185,14 @@ async def test_plot_refreshing(environment):
         *,
         trigger: Callable,
         test_path: Path,
-        expect_loaded: List[MockPlotInfo],
-        expect_removed: List[Path],
+        expect_loaded: list[MockPlotInfo],
+        expect_removed: list[Path],
         expect_processed: int,
         expect_duplicates: int,
         expected_directories: int,
         expect_total_plots: int,
     ):
-        expected_result.loaded = cast(List[PlotInfo], expect_loaded)
+        expected_result.loaded = cast(list[PlotInfo], expect_loaded)
         expected_result.removed = expect_removed
         expected_result.processed = expect_processed
         trigger(env.root_path, str(test_path))
@@ -432,7 +437,7 @@ async def test_invalid_plots(environment):
 @pytest.mark.anyio
 async def test_keys_missing(environment: Environment) -> None:
     env: Environment = environment
-    not_in_keychain_plots: List[Path] = get_test_plots("not_in_keychain")
+    not_in_keychain_plots: list[Path] = get_test_plots("not_in_keychain")
     dir_not_in_keychain: Directory = Directory(env.root_path / "plots" / "not_in_keychain", not_in_keychain_plots)
     expected_result = PlotRefreshResult()
     # The plots in "not_in_keychain" directory have infinity g1 elements as farmer/pool key so they should be plots
@@ -584,7 +589,7 @@ async def test_drop_too_large_cache_entries(environment, bt):
         )
         return path
 
-    def assert_cache(expected: List[MockPlotInfo]) -> None:
+    def assert_cache(expected: list[MockPlotInfo]) -> None:
         test_cache = Cache(cache_path)
         assert len(test_cache) == 0
         test_cache.load()
@@ -736,3 +741,41 @@ async def test_recursive_plot_scan(environment: Environment) -> None:
     add_plot_directory(env.root_path, str(sub_dir_1_0_1.path))
     expected_result.loaded = []
     await env.refresh_tester.run(expected_result)
+
+
+@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:
+    env: Environment = environment
+    # Create a directory tree with some subdirectories containing plots, others not.
+    root_plot_dir = env.root_path / "root"
+    sub_dir_0: Directory = Directory(root_plot_dir / "0", env.dir_1.plots[0:2])
+    sub_dir_0_1: Directory = Directory(sub_dir_0.path / "1", env.dir_1.plots[2:3])
+
+    # Create a plot directory outside of the root plot directory
+    other_plot_dir: Directory = Directory(env.root_path / "other", env.dir_1.plots[3:7])
+
+    # Create a symlink to the other plot directory from inside the root plot directory
+    symlink_path = Path(root_plot_dir / "other")
+    symlink_path.symlink_to(env.root_path / "other")
+
+    # Adding the root without `recursive_plot_scan` and running a test should not load any plots (match an empty result)
+    expected_result = PlotRefreshResult()
+    add_plot_directory(env.root_path, str(root_plot_dir))
+    await env.refresh_tester.run(expected_result)
+
+    if follow_links:
+        expected_plot_list = sub_dir_0.plot_info_list() + sub_dir_0_1.plot_info_list() + other_plot_dir.plot_info_list()
+    else:
+        expected_plot_list = sub_dir_0.plot_info_list() + sub_dir_0_1.plot_info_list()
+
+    # Set the recursive scan flag in the config and symlink flag
+    with lock_and_load_config(env.root_path, "config.yaml") as config:
+        config["harvester"]["recursive_plot_scan"] = True
+        config["harvester"]["recursive_follow_links"] = follow_links
+        save_config(env.root_path, "config.yaml", config)
+
+    # With the flag enabled it should load all expected plots
+    expected_result.loaded = expected_plot_list  # type: ignore[assignment]
+    expected_result.processed = len(expected_plot_list)
+    await env.refresh_tester.run(expected_result)

chia/_tests/plotting/util.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import List
 
 from chia.simulator.block_tools import get_plot_dir
 
 
-def get_test_plots(sub_dir: str = "") -> List[Path]:
+def get_test_plots(sub_dir: str = "") -> list[Path]:
     path = get_plot_dir()
     if sub_dir != "":
-        path = path / sub_dir
+        path /= sub_dir
     return list(sorted(path.glob("*.plot")))

chia/_tests/pools/test_pool_cli_parsing.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from chia._tests.cmds.test_cmd_framework import check_click_parsing
+from chia.cmds.cmd_classes import ChiaCliContext
+from chia.cmds.cmd_helpers import NeedsWalletRPC
+from chia.cmds.param_types import CliAddress
+from chia.cmds.plotnft import (
+    ChangePayoutInstructionsPlotNFTCMD,
+    ClaimPlotNFTCMD,
+    CreatePlotNFTCMD,
+    GetLoginLinkCMD,
+    InspectPlotNFTCMD,
+    JoinPlotNFTCMD,
+    LeavePlotNFTCMD,
+    ShowPlotNFTCMD,
+)
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.bech32m import encode_puzzle_hash
+from chia.util.ints import uint64
+from chia.wallet.util.address_type import AddressType
+
+
+def test_plotnft_command_default_parsing() -> None:
+    launcher_id = bytes32([1] * 32)
+    check_click_parsing(
+        GetLoginLinkCMD(launcher_id=launcher_id),
+        "--launcher_id",
+        launcher_id.hex(),
+    )
+
+    burn_ph = bytes32.from_hexstr("0x000000000000000000000000000000000000000000000000000000000000dead")
+    burn_address = encode_puzzle_hash(burn_ph, "xch")
+    check_click_parsing(
+        ChangePayoutInstructionsPlotNFTCMD(
+            launcher_id=launcher_id, address=CliAddress(burn_ph, burn_address, AddressType.XCH)
+        ),
+        "--launcher_id",
+        launcher_id.hex(),
+        "--address",
+        burn_address,
+        # Needed for AddressParamType to work correctly without config
+        context=ChiaCliContext(expected_prefix="xch"),
+    )
+
+    check_click_parsing(
+        ClaimPlotNFTCMD(
+            rpc_info=NeedsWalletRPC(client_info=None, wallet_rpc_port=None, fingerprint=None), fee=uint64(1), id=5
+        ),
+        "--id",
+        "5",
+        "--fee",
+        "0.000000000001",
+    )
+
+    check_click_parsing(
+        CreatePlotNFTCMD(
+            rpc_info=NeedsWalletRPC(client_info=None, wallet_rpc_port=None, fingerprint=None),
+            pool_url="http://localhost:1234",
+            state="pool",
+            fee=uint64(0),
+            dont_prompt=False,
+        ),
+        "--state",
+        "pool",
+        "--pool-url",
+        "http://localhost:1234",
+        "--fee",
+        "0.0",
+    )
+
+    check_click_parsing(
+        CreatePlotNFTCMD(
+            rpc_info=NeedsWalletRPC(client_info=None, wallet_rpc_port=None, fingerprint=None),
+            pool_url=None,
+            state="local",
+            fee=uint64(0),
+            dont_prompt=True,
+        ),
+        "--state",
+        "local",
+        "-y",
+    )
+
+    check_click_parsing(
+        InspectPlotNFTCMD(
+            rpc_info=NeedsWalletRPC(client_info=None, wallet_rpc_port=None, fingerprint=None),
+            id=5,
+        ),
+        "--id",
+        "5",
+    )
+
+    check_click_parsing(
+        JoinPlotNFTCMD(
+            rpc_info=NeedsWalletRPC(client_info=None, wallet_rpc_port=None, fingerprint=None),
+            id=5,
+            fee=uint64(3),
+            pool_url="http://localhost:1234",
+            dont_prompt=True,
+        ),
+        "--id",
+        "5",
+        "--fee",
+        "0.000000000003",
+        "--pool-url",
+        "http://localhost:1234",
+        "-y",
+    )
+
+    check_click_parsing(
+        LeavePlotNFTCMD(
+            rpc_info=NeedsWalletRPC(client_info=None, wallet_rpc_port=None, fingerprint=None),
+            id=5,
+            fee=uint64(3),
+            dont_prompt=True,
+        ),
+        "--id",
+        "5",
+        "--fee",
+        "0.000000000003",
+        "-y",
+    )
+
+    check_click_parsing(
+        ShowPlotNFTCMD(rpc_info=NeedsWalletRPC(client_info=None, wallet_rpc_port=None, fingerprint=None), id=5),
+        "--id",
+        "5",
+    )