chore: extended missing test for client and network

Signed-off-by: Manish Dait <[email protected]>

Author: manishdait

src/hiero_sdk_python/executable.py

@@ -157,7 +157,9 @@ def set_grpc_deadline(self, grpc_deadline: Union[int, float]):
 
         if self._request_timeout is not None and grpc_deadline > self._request_timeout:
             warnings.warn(
-                "grpc_deadline should be smaller than request_timeout", FutureWarning
+                "grpc_deadline should be smaller than request_timeout. "
+                "This configuration may cause operations to fail unexpectedly."
+                , FutureWarning
             )
 
         self._grpc_deadline = float(grpc_deadline)
@@ -186,7 +188,9 @@ def set_request_timeout(self, request_timeout: Union[int, float]):
 
         if self._grpc_deadline is not None and request_timeout < self._grpc_deadline:
             warnings.warn(
-                "request_timeout should be larger than grpc_deadline,", FutureWarning
+                "request_timeout should be larger than grpc_deadline. "
+                "This configuration may cause operations to fail unexpectedly.",
+                FutureWarning
             )
 
         self._request_timeout = float(request_timeout)

tests/unit/client_test.py

@@ -5,12 +5,13 @@
 from decimal import Decimal
 import os
 import pytest
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 from hiero_sdk_python.client import client as client_module
 
 from hiero_sdk_python import Client, AccountId, PrivateKey
 from hiero_sdk_python.hbar import Hbar
+from hiero_sdk_python.transaction.transaction_id import TransactionId
 
 pytestmark = pytest.mark.unit
 
@@ -466,3 +467,74 @@ def test_update_network_refreshes_nodes_and_returns_self():
         assert returned is client
 
     client.close()
+
+def test_warning_when_grpc_deadline_exceeds_request_timeout():
+    """Warn when grpc_deadline is greater than request_timeout."""
+    client = Client.for_testnet()
+    client.set_request_timeout(2)
+
+    with pytest.warns(FutureWarning):
+        client.set_grpc_deadline(7)
+
+
+def test_warning_when_request_timeout_less_than_grpc_deadline():
+    """Warn when request_timeout is less than grpc_deadline."""
+    client = Client.for_testnet()
+    client.set_grpc_deadline(7)
+
+    with pytest.warns(FutureWarning):
+        client.set_request_timeout(2)
+
+
+def test_generate_transaction_id_requires_operator_set():
+    """Test that generate_transaction_id raises ValueError if operator_account_id is not set."""
+    client = Client.for_testnet()
+    client.operator_account_id = None  # ensure not set
+
+    with pytest.raises(ValueError, match="Operator account ID must be set"):
+        client.generate_transaction_id()
+
+    client.close()
+
+
+def test_generate_transaction_id_returns_transaction_id(monkeypatch):
+    """Test that generate_transaction_id returns a TransactionId object when operator is set."""
+    client = Client.for_testnet()
+    client.operator_account_id = AccountId(0, 0, 1234)
+
+    fake_txid = MagicMock(spec=TransactionId)
+    monkeypatch.setattr("hiero_sdk_python.transaction.transaction_id.TransactionId.generate", lambda account_id: fake_txid)
+
+    txid = client.generate_transaction_id()
+    assert txid is fake_txid
+
+    client.close()
+
+
+def test_get_node_account_ids_returns_correct_list():
+    """Test that get_node_account_ids returns a list of node AccountIds."""
+    client = Client.for_testnet()
+
+    # Mock some nodes with _account_id attributes
+    mock_node1 = MagicMock()
+    mock_node1._account_id = AccountId(0, 0, 1001)
+    mock_node2 = MagicMock()
+    mock_node2._account_id = AccountId(0, 0, 1002)
+
+    client.network.nodes = [mock_node1, mock_node2]
+
+    node_ids = client.get_node_account_ids()
+    assert node_ids == [mock_node1._account_id, mock_node2._account_id]
+
+    client.close()
+
+
+def test_get_node_account_ids_raises_when_no_nodes():
+    """Test that get_node_account_ids raises ValueError if no nodes are configured."""
+    client = Client.for_testnet()
+    client.network.nodes = []
+
+    with pytest.raises(ValueError, match="No nodes available"):
+        client.get_node_account_ids()
+
+    client.close()

tests/unit/network_test.py

@@ -361,3 +361,90 @@ def test_get_node_returns_none_when_not_found():
     network._healthy_nodes = [node]
 
     assert network._get_node("0.0.999") is None
+
+
+# Tests parse_mirror_address
+@pytest.mark.parametrize(
+    "mirror_addr,expected_host,expected_port",
+    [
+        ("localhost:5551", "localhost", 5551),
+        ("127.0.0.1:8080", "127.0.0.1", 8080),
+        ("mirror.hedera.com:443", "mirror.hedera.com", 443),
+        ("justhost", "justhost", 443),  # no port defaults to 443
+        ("badport:abc", "badport", 443),  # invalid port defaults to 443
+    ],
+)
+def test_parse_mirror_address(mirror_addr, expected_host, expected_port):
+    """Test that _parse_mirror_address correctly splits mirror_address into host and port."""
+    network = Network("testnet", mirror_address=mirror_addr)
+    host, port = network._parse_mirror_address()
+    assert host == expected_host
+    assert port == expected_port
+
+
+# Tests _determine_scheme_and_port
+@pytest.mark.parametrize(
+    "host,port,expected_scheme,expected_port",
+    [
+        ("localhost", 443, "http", 8080),
+        ("127.0.0.1", 80, "http", 80),
+        ("127.0.0.1", 5000, "http", 5000),
+        ("hedera.com", 5600, "https", 443),
+        ("hedera.com", 443, "https", 443),
+        ("hedera.com", 8443, "https", 8443),
+    ],
+)
+def test_determine_scheme_and_port(host, port, expected_scheme, expected_port):
+    """Test that _determine_scheme_and_port correctly computes the scheme (http/https)."""
+    network = Network("testnet")
+    scheme, out_port = network._determine_scheme_and_port(host, port)
+    assert out_port == expected_port
+    assert scheme == expected_scheme
+
+
+# Tests for _build_rest_url
+@pytest.mark.parametrize(
+    "scheme,host,port,expected_url",
+    [
+        ("https", "hedera.com", 443, "https://hedera.com/api/v1"),
+        ("https", "hedera.com", 8443, "https://hedera.com:8443/api/v1"),
+        ("http", "localhost", 80, "http://localhost/api/v1"),
+        ("http", "localhost", 8080, "http://localhost:8080/api/v1"),
+    ],
+)
+def test_build_rest_url(scheme, host, port, expected_url):
+    """Test that _build_rest_url constructs the correct REST API URL."""
+    network = Network("testnet")
+    url = network._build_rest_url(scheme, host, port)
+    assert url == expected_url
+
+
+def test_get_mirror_rest_url_fallback():
+    """Test get_mirror_rest_url fallback behavior when network is not in MIRROR_NODE_URLS."""
+    # Custom network with no entry in MIRROR_NODE_URLS
+    network = Network("customnet", mirror_address="localhost:1234")
+
+    scheme, port = network._determine_scheme_and_port(*network._parse_mirror_address())
+    expected_url = network._build_rest_url(scheme, "localhost", port)
+
+    assert network.get_mirror_rest_url() == expected_url
+
+
+@pytest.mark.unit
+def test_resolve_nodes_fallback_to_default(monkeypatch):
+    """Test that _resolve_nodes falls back to DEFAULT_NODES if no nodes are provided and mirror fetch returns empty."""
+    network_name = "testnet"
+    network = Network(network_name)
+
+    # Patch _fetch_nodes_from_mirror_node to return empty list
+    monkeypatch.setattr(network, "_fetch_nodes_from_mirror_node", lambda: [])
+
+    # Call _resolve_nodes with nodes=None should fallback to DEFAULT_NODES
+    resolved_nodes = network._resolve_nodes(None)
+
+    # DEFAULT_NODES for testnet has 4 entries (0..3)
+    expected_count = len(network.DEFAULT_NODES[network_name])
+    assert isinstance(resolved_nodes, list)
+    assert all(isinstance(n, _Node) for n in resolved_nodes)
+    assert len(resolved_nodes) == expected_count
+    assert resolved_nodes[0]._account_id == network.DEFAULT_NODES[network_name][0][1]