chia-blockchain 2.4.4__py3-none-any.whl

chia/_tests/core/server/test_rate_limits.py

@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+import asyncio
+from typing import List
+
+import pytest
+
+from chia._tests.conftest import node_with_params
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.protocols.shared_protocol import Capability
+from chia.server.outbound_message import make_msg
+from chia.server.rate_limit_numbers import compose_rate_limits, get_rate_limits_to_use
+from chia.server.rate_limit_numbers import rate_limits as rl_numbers
+from chia.server.rate_limits import RateLimiter
+from chia.server.server import ChiaServer
+from chia.server.ws_connection import WSChiaConnection
+from chia.types.peer_info import PeerInfo
+
+rl_v2 = [Capability.BASE, Capability.BLOCK_HEADERS, Capability.RATE_LIMITS_V2]
+rl_v1 = [Capability.BASE]
+node_with_params_b = node_with_params
+test_different_versions_results: List[int] = []
+
+
+class TestRateLimits:
+    @pytest.mark.anyio
+    async def test_get_rate_limits_to_use(self):
+        assert get_rate_limits_to_use(rl_v2, rl_v2) != get_rate_limits_to_use(rl_v2, rl_v1)
+        assert get_rate_limits_to_use(rl_v1, rl_v1) == get_rate_limits_to_use(rl_v2, rl_v1)
+        assert get_rate_limits_to_use(rl_v1, rl_v1) == get_rate_limits_to_use(rl_v1, rl_v2)
+
+    @pytest.mark.anyio
+    async def test_too_many_messages(self):
+        # Too many messages
+        r = RateLimiter(incoming=True)
+        new_tx_message = make_msg(ProtocolMessageTypes.new_transaction, bytes([1] * 40))
+        for i in range(4999):
+            assert r.process_msg_and_check(new_tx_message, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(4999):
+            response = r.process_msg_and_check(new_tx_message, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+
+        # Non-tx message
+        r = RateLimiter(incoming=True)
+        new_peak_message = make_msg(ProtocolMessageTypes.new_peak, bytes([1] * 40))
+        for i in range(200):
+            assert r.process_msg_and_check(new_peak_message, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(200):
+            response = r.process_msg_and_check(new_peak_message, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+
+    @pytest.mark.anyio
+    async def test_large_message(self):
+        # Large tx
+        small_tx_message = make_msg(ProtocolMessageTypes.respond_transaction, bytes([1] * 500 * 1024))
+        large_tx_message = make_msg(ProtocolMessageTypes.new_transaction, bytes([1] * 3 * 1024 * 1024))
+
+        r = RateLimiter(incoming=True)
+        assert r.process_msg_and_check(small_tx_message, rl_v2, rl_v2)
+        assert not r.process_msg_and_check(large_tx_message, rl_v2, rl_v2)
+
+        small_vdf_message = make_msg(ProtocolMessageTypes.respond_signage_point, bytes([1] * 5 * 1024))
+        large_vdf_message = make_msg(ProtocolMessageTypes.respond_signage_point, bytes([1] * 600 * 1024))
+        r = RateLimiter(incoming=True)
+        assert r.process_msg_and_check(small_vdf_message, rl_v2, rl_v2)
+        assert r.process_msg_and_check(small_vdf_message, rl_v2, rl_v2)
+        assert not r.process_msg_and_check(large_vdf_message, rl_v2, rl_v2)
+
+    @pytest.mark.anyio
+    async def test_too_much_data(self):
+        # Too much data
+        r = RateLimiter(incoming=True)
+        tx_message = make_msg(ProtocolMessageTypes.respond_transaction, bytes([1] * 500 * 1024))
+        for i in range(40):
+            assert r.process_msg_and_check(tx_message, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(300):
+            response = r.process_msg_and_check(tx_message, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+
+        r = RateLimiter(incoming=True)
+        block_message = make_msg(ProtocolMessageTypes.respond_block, bytes([1] * 1024 * 1024))
+        for i in range(10):
+            assert r.process_msg_and_check(block_message, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(40):
+            response = r.process_msg_and_check(block_message, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+
+    @pytest.mark.anyio
+    async def test_non_tx_aggregate_limits(self):
+        # Frequency limits
+        r = RateLimiter(incoming=True)
+        message_1 = make_msg(ProtocolMessageTypes.coin_state_update, bytes([1] * 32))
+        message_2 = make_msg(ProtocolMessageTypes.request_blocks, bytes([1] * 64))
+        message_3 = make_msg(ProtocolMessageTypes.plot_sync_start, bytes([1] * 64))
+
+        for i in range(500):
+            assert r.process_msg_and_check(message_1, rl_v2, rl_v2)
+
+        for i in range(500):
+            assert r.process_msg_and_check(message_2, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(500):
+            response = r.process_msg_and_check(message_3, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+
+        # Size limits
+        r = RateLimiter(incoming=True)
+        message_4 = make_msg(ProtocolMessageTypes.respond_proof_of_weight, bytes([1] * 49 * 1024 * 1024))
+        message_5 = make_msg(ProtocolMessageTypes.respond_blocks, bytes([1] * 49 * 1024 * 1024))
+
+        for i in range(2):
+            assert r.process_msg_and_check(message_4, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(2):
+            response = r.process_msg_and_check(message_5, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+
+    @pytest.mark.anyio
+    async def test_periodic_reset(self):
+        r = RateLimiter(True, 5)
+        tx_message = make_msg(ProtocolMessageTypes.respond_transaction, bytes([1] * 500 * 1024))
+        for i in range(10):
+            assert r.process_msg_and_check(tx_message, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(300):
+            response = r.process_msg_and_check(tx_message, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+        assert not r.process_msg_and_check(tx_message, rl_v2, rl_v2)
+        await asyncio.sleep(6)
+        assert r.process_msg_and_check(tx_message, rl_v2, rl_v2)
+
+        # Counts reset also
+        r = RateLimiter(True, 5)
+        new_tx_message = make_msg(ProtocolMessageTypes.new_transaction, bytes([1] * 40))
+        for i in range(4999):
+            assert r.process_msg_and_check(new_tx_message, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(4999):
+            response = r.process_msg_and_check(new_tx_message, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+        await asyncio.sleep(6)
+        assert r.process_msg_and_check(new_tx_message, rl_v2, rl_v2)
+
+    @pytest.mark.anyio
+    async def test_percentage_limits(self):
+        r = RateLimiter(True, 60, 40)
+        new_peak_message = make_msg(ProtocolMessageTypes.new_peak, bytes([1] * 40))
+        for i in range(50):
+            assert r.process_msg_and_check(new_peak_message, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(50):
+            response = r.process_msg_and_check(new_peak_message, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+
+        r = RateLimiter(True, 60, 40)
+        block_message = make_msg(ProtocolMessageTypes.respond_block, bytes([1] * 1024 * 1024))
+        for i in range(5):
+            assert r.process_msg_and_check(block_message, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(5):
+            response = r.process_msg_and_check(block_message, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+
+        # Aggregate percentage limit count
+        r = RateLimiter(True, 60, 40)
+        message_1 = make_msg(ProtocolMessageTypes.coin_state_update, bytes([1] * 5))
+        message_2 = make_msg(ProtocolMessageTypes.request_blocks, bytes([1] * 32))
+        message_3 = make_msg(ProtocolMessageTypes.plot_sync_start, bytes([1] * 32))
+
+        for i in range(180):
+            assert r.process_msg_and_check(message_1, rl_v2, rl_v2)
+        for i in range(180):
+            assert r.process_msg_and_check(message_2, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(100):
+            response = r.process_msg_and_check(message_3, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+
+        # Aggregate percentage limit max total size
+        r = RateLimiter(True, 60, 40)
+        message_4 = make_msg(ProtocolMessageTypes.respond_proof_of_weight, bytes([1] * 18 * 1024 * 1024))
+        message_5 = make_msg(ProtocolMessageTypes.respond_blocks, bytes([1] * 24 * 1024 * 1024))
+
+        for i in range(2):
+            assert r.process_msg_and_check(message_4, rl_v2, rl_v2)
+
+        saw_disconnect = False
+        for i in range(2):
+            response = r.process_msg_and_check(message_5, rl_v2, rl_v2)
+            if not response:
+                saw_disconnect = True
+        assert saw_disconnect
+
+    @pytest.mark.anyio
+    async def test_too_many_outgoing_messages(self):
+        # Too many messages
+        r = RateLimiter(incoming=False)
+        new_peers_message = make_msg(ProtocolMessageTypes.respond_peers, bytes([1]))
+        non_tx_freq = get_rate_limits_to_use(rl_v2, rl_v2)["non_tx_freq"]
+
+        passed = 0
+        blocked = 0
+        for i in range(non_tx_freq):
+            if r.process_msg_and_check(new_peers_message, rl_v2, rl_v2):
+                passed += 1
+            else:
+                blocked += 1
+
+        assert passed == 10
+        assert blocked == non_tx_freq - passed
+
+        # ensure that *another* message type is not blocked because of this
+
+        new_signatures_message = make_msg(ProtocolMessageTypes.respond_signatures, bytes([1]))
+        assert r.process_msg_and_check(new_signatures_message, rl_v2, rl_v2)
+
+    @pytest.mark.anyio
+    async def test_too_many_incoming_messages(self):
+        # Too many messages
+        r = RateLimiter(incoming=True)
+        new_peers_message = make_msg(ProtocolMessageTypes.respond_peers, bytes([1]))
+        non_tx_freq = get_rate_limits_to_use(rl_v2, rl_v2)["non_tx_freq"]
+
+        passed = 0
+        blocked = 0
+        for i in range(non_tx_freq):
+            if r.process_msg_and_check(new_peers_message, rl_v2, rl_v2):
+                passed += 1
+            else:
+                blocked += 1
+
+        assert passed == 10
+        assert blocked == non_tx_freq - passed
+
+        # ensure that other message types *are* blocked because of this
+
+        new_signatures_message = make_msg(ProtocolMessageTypes.respond_signatures, bytes([1]))
+        assert not r.process_msg_and_check(new_signatures_message, rl_v2, rl_v2)
+
+    @pytest.mark.parametrize(
+        "node_with_params",
+        [
+            pytest.param(
+                dict(
+                    disable_capabilities=[Capability.BLOCK_HEADERS, Capability.RATE_LIMITS_V2],
+                ),
+                id="V1",
+            ),
+            pytest.param(
+                dict(
+                    disable_capabilities=[],
+                ),
+                id="V2",
+            ),
+        ],
+        indirect=True,
+    )
+    @pytest.mark.parametrize(
+        "node_with_params_b",
+        [
+            pytest.param(
+                dict(
+                    disable_capabilities=[Capability.BLOCK_HEADERS, Capability.RATE_LIMITS_V2],
+                ),
+                id="V1",
+            ),
+            pytest.param(
+                dict(
+                    disable_capabilities=[],
+                ),
+                id="V2",
+            ),
+        ],
+        indirect=True,
+    )
+    @pytest.mark.anyio
+    @pytest.mark.limit_consensus_modes(reason="save time")
+    async def test_different_versions(self, node_with_params, node_with_params_b, self_hostname):
+        node_a = node_with_params
+        node_b = node_with_params_b
+
+        full_node_server_a: ChiaServer = node_a.full_node.server
+        full_node_server_b: ChiaServer = node_b.full_node.server
+
+        await full_node_server_b.start_client(PeerInfo(self_hostname, full_node_server_a.get_port()), None)
+
+        assert len(full_node_server_b.get_connections()) == 1
+        assert len(full_node_server_a.get_connections()) == 1
+
+        a_con: WSChiaConnection = full_node_server_a.get_connections()[0]
+        b_con: WSChiaConnection = full_node_server_b.get_connections()[0]
+
+        print(a_con.local_capabilities, a_con.peer_capabilities)
+        print(b_con.local_capabilities, b_con.peer_capabilities)
+
+        # The two nodes will use the same rate limits even if their versions are different
+        assert get_rate_limits_to_use(a_con.local_capabilities, a_con.peer_capabilities) == get_rate_limits_to_use(
+            b_con.local_capabilities, b_con.peer_capabilities
+        )
+
+        # The following code checks whether all of the runs resulted in the same number of items in "rate_limits_tx",
+        # which would mean the same rate limits are always used. This should not happen, since two nodes with V2
+        # will use V2.
+        total_tx_msg_count = len(
+            get_rate_limits_to_use(a_con.local_capabilities, a_con.peer_capabilities)["rate_limits_tx"]
+        )
+
+        test_different_versions_results.append(total_tx_msg_count)
+        if len(test_different_versions_results) >= 4:
+            assert len(set(test_different_versions_results)) >= 2
+
+    @pytest.mark.anyio
+    async def test_compose(self):
+        rl_1 = rl_numbers[1]
+        rl_2 = rl_numbers[2]
+        assert ProtocolMessageTypes.respond_children in rl_1["rate_limits_other"]
+        assert ProtocolMessageTypes.respond_children not in rl_1["rate_limits_tx"]
+        assert ProtocolMessageTypes.respond_children not in rl_2["rate_limits_other"]
+        assert ProtocolMessageTypes.respond_children in rl_2["rate_limits_tx"]
+
+        assert ProtocolMessageTypes.request_block in rl_1["rate_limits_other"]
+        assert ProtocolMessageTypes.request_block not in rl_1["rate_limits_tx"]
+        assert ProtocolMessageTypes.request_block not in rl_2["rate_limits_other"]
+        assert ProtocolMessageTypes.request_block not in rl_2["rate_limits_tx"]
+
+        comps = compose_rate_limits(rl_1, rl_2)
+        # v2 limits are used if present
+        assert ProtocolMessageTypes.respond_children not in comps["rate_limits_other"]
+        assert ProtocolMessageTypes.respond_children in comps["rate_limits_tx"]
+
+        # Otherwise, fall back to v1
+        assert ProtocolMessageTypes.request_block in rl_1["rate_limits_other"]
+        assert ProtocolMessageTypes.request_block not in rl_1["rate_limits_tx"]

chia/_tests/core/server/test_server.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Callable, Tuple, cast
+
+import pytest
+from packaging.version import Version
+
+from chia import __version__
+from chia._tests.connection_utils import connect_and_get_peer
+from chia._tests.util.setup_nodes import SimulatorsAndWalletsServices
+from chia._tests.util.time_out_assert import time_out_assert
+from chia.full_node.full_node_api import FullNodeAPI
+from chia.protocols.full_node_protocol import RejectBlock, RequestBlock, RequestTransaction
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.protocols.shared_protocol import Error, protocol_version
+from chia.protocols.wallet_protocol import RejectHeaderRequest
+from chia.server.outbound_message import NodeType, make_msg
+from chia.server.server import ChiaServer
+from chia.server.start_full_node import create_full_node_service
+from chia.server.start_wallet import create_wallet_service
+from chia.server.ws_connection import WSChiaConnection, error_response_version
+from chia.simulator.block_tools import BlockTools
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.peer_info import PeerInfo
+from chia.util.api_decorators import api_request
+from chia.util.errors import ApiError, Err
+from chia.util.ints import int16, uint32
+
+
+@dataclass
+class TestAPI:
+    log: logging.Logger = logging.getLogger(__name__)
+
+    def ready(self) -> bool:
+        return True
+
+    # API call from FullNodeAPI
+    @api_request()
+    async def request_transaction(self, request: RequestTransaction) -> None:
+        raise ApiError(Err.NO_TRANSACTIONS_WHILE_SYNCING, f"Some error message: {request.transaction_id}", b"ab")
+
+
+@pytest.mark.anyio
+async def test_duplicate_client_connection(
+    two_nodes: Tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools], self_hostname: str
+) -> None:
+    _, _, server_1, server_2, _ = two_nodes
+    assert await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+    assert not await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("method", [repr, str])
+async def test_connection_string_conversion(
+    two_nodes_one_block: Tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools],
+    self_hostname: str,
+    method: Callable[[object], str],
+) -> None:
+    _, _, server_1, server_2, _ = two_nodes_one_block
+    peer = await connect_and_get_peer(server_1, server_2, self_hostname)
+    # 1000 is based on the current implementation (example below), should be reconsidered/adjusted if this test fails
+    # WSChiaConnection(local_type=<NodeType.FULL_NODE: 1>, local_port=50632, local_capabilities=[<Capability.BASE: 1>, <Capability.BLOCK_HEADERS: 2>, <Capability.RATE_LIMITS_V2: 3>], peer_host='127.0.0.1', peer_port=50640, peer_node_id=<bytes32: 566a318f0f656125b4fef0e85fbddcf9bc77f8003d35293c392479fc5d067f4d>, outbound_rate_limiter=<chia.server.rate_limits.RateLimiter object at 0x114a13f50>, inbound_rate_limiter=<chia.server.rate_limits.RateLimiter object at 0x114a13e90>, is_outbound=False, creation_time=1675271096.275591, bytes_read=68, bytes_written=162, last_message_time=1675271096.276271, peer_server_port=50636, active=False, closed=False, connection_type=<NodeType.FULL_NODE: 1>, request_nonce=32768, peer_capabilities=[<Capability.BASE: 1>, <Capability.BLOCK_HEADERS: 2>, <Capability.RATE_LIMITS_V2: 3>], version='', protocol_version='') # noqa
+    converted = method(peer)
+    print(converted)
+    assert len(converted) < 1000
+
+
+@pytest.mark.anyio
+async def test_connection_versions(
+    self_hostname: str, one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices
+) -> None:
+    [full_node_service], [wallet_service], _ = one_wallet_and_one_simulator_services
+    wallet_node = wallet_service._node
+    full_node = full_node_service._node
+    await wallet_node.server.start_client(
+        PeerInfo(self_hostname, cast(FullNodeAPI, full_node_service._api).server.get_port()), None
+    )
+    outgoing_connection = wallet_node.server.all_connections[full_node.server.node_id]
+    incoming_connection = full_node.server.all_connections[wallet_node.server.node_id]
+    for connection in [outgoing_connection, incoming_connection]:
+        assert connection.protocol_version == Version(protocol_version[NodeType.WALLET])
+        assert connection.version == __version__
+        assert connection.get_version() == connection.version
+
+
+@pytest.mark.anyio
+async def test_api_not_ready(
+    self_hostname: str,
+    one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    [full_node_service], [wallet_service], _ = one_wallet_and_one_simulator_services
+    wallet_node = wallet_service._node
+    full_node = full_node_service._node
+    await wallet_node.server.start_client(
+        PeerInfo(self_hostname, cast(FullNodeAPI, full_node_service._api).server.get_port()), None
+    )
+    wallet_node.log_out()
+    assert not wallet_service._api.ready()
+    connection = full_node.server.all_connections[wallet_node.server.node_id]
+
+    def request_ignored() -> bool:
+        return "API not ready, ignore request: {'data': '0x00000000', 'id': None, 'type': 53}" in caplog.text
+
+    with caplog.at_level(logging.WARNING):
+        assert await connection.send_message(
+            make_msg(ProtocolMessageTypes.reject_header_request, RejectHeaderRequest(uint32(0)))
+        )
+        await time_out_assert(10, request_ignored)
+
+
+@pytest.mark.parametrize("version", ["0.0.34", "0.0.35", "0.0.36"])
+@pytest.mark.anyio
+async def test_error_response(
+    one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices,
+    self_hostname: str,
+    caplog: pytest.LogCaptureFixture,
+    version: str,
+) -> None:
+    [full_node_service], [wallet_service], _ = one_wallet_and_one_simulator_services
+    wallet_node = wallet_service._node
+    full_node = full_node_service._node
+
+    full_node.server.api = TestAPI()
+
+    await wallet_node.server.start_client(
+        PeerInfo(self_hostname, cast(FullNodeAPI, full_node_service._api).server.get_port()), None
+    )
+    wallet_connection = full_node.server.all_connections[wallet_node.server.node_id]
+    full_node_connection = wallet_node.server.all_connections[full_node.server.node_id]
+    test_version = Version(version)
+    wallet_connection.protocol_version = test_version
+    request = RequestTransaction(bytes32(32 * b"1"))
+    error_message = f"Some error message: {request.transaction_id}"
+    with caplog.at_level(logging.DEBUG):
+        response = await full_node_connection.call_api(TestAPI.request_transaction, request, timeout=5)
+        error = ApiError(Err.NO_TRANSACTIONS_WHILE_SYNCING, error_message)
+        assert f"ApiError: {error} from {wallet_connection.peer_node_id}, {wallet_connection.peer_info}" in caplog.text
+        if test_version >= error_response_version:
+            assert response == Error(int16(Err.NO_TRANSACTIONS_WHILE_SYNCING.value), error_message, b"ab")
+            assert "Request timeout:" not in caplog.text
+        else:
+            assert response is None
+            assert "Request timeout:" in caplog.text
+
+
+@pytest.mark.parametrize(
+    "error", [Error(int16(Err.UNKNOWN.value), "1", bytes([1, 2, 3])), Error(int16(Err.UNKNOWN.value), "2", None)]
+)
+@pytest.mark.anyio
+async def test_error_receive(
+    one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices,
+    self_hostname: str,
+    caplog: pytest.LogCaptureFixture,
+    error: Error,
+) -> None:
+    [full_node_service], [wallet_service], _ = one_wallet_and_one_simulator_services
+    wallet_node = wallet_service._node
+    full_node = full_node_service._node
+    await wallet_node.server.start_client(
+        PeerInfo(self_hostname, cast(FullNodeAPI, full_node_service._api).server.get_port()), None
+    )
+    wallet_connection = full_node.server.all_connections[wallet_node.server.node_id]
+    full_node_connection = wallet_node.server.all_connections[full_node.server.node_id]
+    message = make_msg(ProtocolMessageTypes.error, error)
+
+    def error_log_found(connection: WSChiaConnection) -> bool:
+        return f"ApiError: {error} from {connection.peer_node_id}, {connection.peer_info}" in caplog.text
+
+    with caplog.at_level(logging.WARNING):
+        await full_node_connection.outgoing_queue.put(message)
+        await wallet_connection.outgoing_queue.put(message)
+        await time_out_assert(10, error_log_found, True, full_node_connection)
+        await time_out_assert(10, error_log_found, True, wallet_connection)
+
+
+@pytest.mark.anyio
+async def test_call_api_of_specific(
+    two_nodes: Tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools], self_hostname: str
+) -> None:
+    _, _, server_1, server_2, _ = two_nodes
+    assert await server_1.start_client(PeerInfo(self_hostname, server_2.get_port()), None)
+
+    message = await server_1.call_api_of_specific(
+        FullNodeAPI.request_block, RequestBlock(uint32(42), False), server_2.node_id
+    )
+
+    assert message is not None
+    assert isinstance(message, RejectBlock)
+
+
+@pytest.mark.anyio
+async def test_call_api_of_specific_for_missing_peer(
+    two_nodes: Tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools]
+) -> None:
+    _, _, server_1, server_2, _ = two_nodes
+
+    message = await server_1.call_api_of_specific(
+        FullNodeAPI.request_block, RequestBlock(uint32(42), False), server_2.node_id
+    )
+
+    assert message is None
+
+
+@pytest.mark.limit_consensus_modes(reason="save time")
+@pytest.mark.anyio
+async def test_get_peer_info(bt: BlockTools) -> None:
+    wallet_service = create_wallet_service(
+        bt.root_path, bt.config, bt.constants, keychain=None, connect_to_daemon=False
+    )
+
+    # Wallet server should not have a port or peer info
+    with pytest.raises(ValueError, match="Port not set"):
+        local_port = wallet_service._server.get_port()
+    local_peer_info = await wallet_service._server.get_peer_info()
+    assert local_peer_info is None
+
+    # Full node server should have a local port
+    # testing get_peer_info() directly is flakey because it depends on IP lookup
+    # from either chia or aws
+    node_service = await create_full_node_service(bt.root_path, bt.config, bt.constants, connect_to_daemon=False)
+    local_port = node_service._server.get_port()
+    assert local_port is not None

chia/_tests/core/server/test_upnp.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+
+def test_miniupnpc_imports_successfully() -> None:
+    import miniupnpc
+
+    # use it to avoid all related warnings
+    assert miniupnpc is not None

chia/_tests/core/services/config.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+parallel = False