chore: cleanup unit test

Signed-off-by: exploreriii <[email protected]>

Author: exploreriii

tests/unit/conftest.py

@@ -1,4 +1,5 @@
 import pytest
+import time
 from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.client.network import Network
 from hiero_sdk_python.client.client import Client
@@ -9,6 +10,7 @@
 from hiero_sdk_python.tokens.nft_id import NftId
 from hiero_sdk_python.tokens.token_id import TokenId
 from hiero_sdk_python.transaction.transaction_id import TransactionId
+from hiero_sdk_python.hapi.services import timestamp_pb2
 
 @pytest.fixture
 def mock_account_ids():
@@ -20,6 +22,34 @@ def mock_account_ids():
     token_id_2 = TokenId(2, 2, 2)
     return account_id_sender, account_id_recipient, node_account_id, token_id_1, token_id_2
 
+@pytest.fixture
+def mock_client():
+    """Fixture to provide a mock client with hardcoded nodes for testing purposes."""
+    nodes = [_Node(AccountId(0, 0, 3), "node1.example.com:50211", None)]
+    network = Network(nodes=nodes)
+    client = Client(network)
+    client.logger.set_level(LogLevel.DISABLED)
+
+    operator_key = PrivateKey.generate()
+    operator_id = AccountId(0, 0, 1984)
+    client.set_operator(operator_id, operator_key)
+
+    return client
+
+@pytest.fixture
+def generate_transaction_id():
+    """
+    Return a factory which, given an AccountId proto, returns a TransactionId
+    stamped with the current time.
+    """
+    def _make(account_id_proto):
+        now = time.time()
+        secs = int(now)
+        nanos = int((now - secs) * 1e9)
+        ts = timestamp_pb2.Timestamp(seconds=secs, nanos=nanos)
+        return TransactionId(valid_start=ts, account_id=account_id_proto)
+    return _make
+
 @pytest.fixture
 def amount():
     """Fixture to provide a default amount for fungible tokens."""
@@ -52,16 +82,3 @@ def nft_id():
     serial_number = 8
     return NftId(tokenId=token_id, serialNumber=serial_number)
 
-@pytest.fixture
-def mock_client():
-    """Fixture to provide a mock client with hardcoded nodes for testing purposes."""
-    nodes = [_Node(AccountId(0, 0, 3), "node1.example.com:50211", None)]
-    network = Network(nodes=nodes)
-    client = Client(network)
-    client.logger.set_level(LogLevel.DISABLED)
-
-    operator_key = PrivateKey.generate()
-    operator_id = AccountId(0, 0, 1984)
-    client.set_operator(operator_id, operator_key)
-
-    return client

tests/unit/test_token_pause_transaction.py

@@ -1,134 +1,135 @@
+import time
 import pytest
 from unittest.mock import MagicMock
 
+from hiero_sdk_python.hapi.services import (
+    response_header_pb2,
+    response_pb2,
+    timestamp_pb2,
+    transaction_get_receipt_pb2,
+)
 from hiero_sdk_python.hapi.services.transaction_receipt_pb2 import TransactionReceipt as TransactionReceiptProto
 from hiero_sdk_python.hapi.services.transaction_response_pb2 import TransactionResponse as TransactionResponseProto
+
 from hiero_sdk_python.response_code import ResponseCode
 from hiero_sdk_python.tokens.token_pause_transaction import TokenPauseTransaction
-from hiero_sdk_python.hapi.services import response_header_pb2, response_pb2, timestamp_pb2, transaction_get_receipt_pb2
-from hiero_sdk_python.transaction.transaction_id import TransactionId
 from hiero_sdk_python.tokens.token_id import TokenId
+from hiero_sdk_python.transaction.transaction_id import TransactionId
 
 from tests.unit.mock_server import mock_hedera_servers
 
 pytestmark = pytest.mark.unit
 
-def generate_transaction_id(account_id_proto):
-    """Generate a unique transaction ID based on the account ID and the current timestamp."""
-    import time
-    current_time = time.time()
-    timestamp_seconds = int(current_time)
-    timestamp_nanos = int((current_time - timestamp_seconds) * 1e9)
+@pytest.fixture
+def built_pause_tx(mock_account_ids, mock_client, generate_transaction_id):
+    """
+    Factory fixture: given a pause_key, returns a TokenPauseTransaction
+    that’s already set up, frozen, and signed with that key.
+    """
+    sender, _, node_account, fungible_token, _ = mock_account_ids
 
-    tx_timestamp = timestamp_pb2.Timestamp(seconds=timestamp_seconds, nanos=timestamp_nanos)
+    def _make(pause_key):
+        tx = TokenPauseTransaction().set_token_id(fungible_token)
+        tx.transaction_id  = generate_transaction_id(sender)
+        tx.node_account_id = node_account
+        tx.freeze_with(mock_client)
+        tx.sign(pause_key)
+        return tx
+
+    return _make
 
-    tx_id = TransactionId(
-        valid_start=tx_timestamp,
-        account_id=account_id_proto
-    )
-    return tx_id
 
-def test_builds_token_pause_body_with_correct_token_id(mock_account_ids):
+def test_builds_token_pause_body_with_correct_ids(mock_account_ids, generate_transaction_id):
     """
-    Given a TokenPauseTransaction with a valid token_id set, when building the
-    transaction body, then the inner `tokenPause.token` fields should match.
+    build_transaction_body() should embed:
+      - tokenPause.token   == token_id.to_proto()
+      - transactionID      == transaction_id.to_proto()
+      - nodeAccountID      == node_account_id.to_proto()
     """
-    account_id, node_account_id, token_id, _ = mock_account_ids
+    sender, _, node_account, token_id, _ = mock_account_ids
 
-    pause_tx = (
-        TokenPauseTransaction()
-        .set_token_id(token_id)
-    )
-    
-    pause_tx.transaction_id = generate_transaction_id(account_id)
-    pause_tx.node_account_id = node_account_id
+    pause_tx = TokenPauseTransaction().set_token_id(token_id)
+    pause_tx.transaction_id  = generate_transaction_id(sender)
+    pause_tx.node_account_id = node_account
 
-    transaction_body = pause_tx.build_transaction_body()
+    body = pause_tx.build_transaction_body()
 
-    expected = token_id.to_proto()
-    assert transaction_body.tokenPause.token == expected
+    assert body.tokenPause.token  == token_id.to_proto()
+    assert body.transactionID         == pause_tx.transaction_id.to_proto()
+    assert body.nodeAccountID         == pause_tx.node_account_id.to_proto()
 
-    assert transaction_body.transactionID == pause_tx.transaction_id.to_proto()
-    assert transaction_body.nodeAccountID == pause_tx.node_account_id.to_proto()
 
-@pytest.mark.parametrize("bad_token", [None, TokenId(0,0,0)])
+@pytest.mark.parametrize("bad_token", [None, TokenId(0, 0, 0)])
 def test_build_transaction_body_without_valid_token_id_raises(bad_token):
-    """Building a transaction body without a valid token_id must raise ValueError."""
-    tx = TokenPauseTransaction()
+    """
+    If token_id is missing or zero, build_transaction_body() must ValueError.
+    """
+    pause_tx = TokenPauseTransaction()
     if bad_token is not None:
-        tx.token_id = bad_token
-    with pytest.raises(ValueError):
-        tx.build_transaction_body()
-
-# This test uses fixture (mock_account_ids, mock_client) as parameter
-def test_signed_bytes_include_token_pause_transaction(mock_account_ids, mock_client):
-    """Test converting the token pause transaction to protobuf format after signing."""
-    account_id, _, token_id, _ = mock_account_ids
-    
-    pause_tx = (
-        TokenPauseTransaction()
-        .set_token_id(token_id)
-    )
-    
-    pause_tx.transaction_id = generate_transaction_id(account_id)
+        pause_tx.token_id = bad_token
 
+    with pytest.raises(ValueError, match="token_id must be set"):
+        pause_tx.build_transaction_body()
+
+def test_signed_bytes_include_token_pause_transaction(built_pause_tx):
+    """
+    After freeze() and sign(pause_key), to_proto() must embed a non-empty
+    signedTransactionBytes blob.
+    """
+    # Arrange: stub pause key + public key
     pause_key = MagicMock()
-    pause_key.sign.return_value = b'signature'
-    pause_key.public_key().to_bytes_raw.return_value = b'public_key'
-    
-    pause_tx.freeze_with(mock_client)
+    pause_key.sign.return_value = b'__FAKE_SIG__'
 
-    pause_tx.sign(pause_key)
+    fake_pub = pause_key.public_key()
+    fake_pub.to_bytes_raw.return_value = b'__FAKE_PUB__'
+
+    # Act
+    pause_tx = built_pause_tx(pause_key)
     proto = pause_tx.to_proto()
 
+    # Assert
     assert proto.signedTransactionBytes
     assert len(proto.signedTransactionBytes) > 0
 
-# This test uses fixture mock_account_ids as parameter
 def test_pause_transaction_can_execute(mock_account_ids):
-    """Test that a pause transaction can be executed successfully."""
-    account_id, node_account_id, token_id, _ = mock_account_ids
-
-    # Create test transaction responses
-    ok_response = TransactionResponseProto()
-    ok_response.nodeTransactionPrecheckCode = ResponseCode.OK
-    
-    # Create a mock receipt for a successful token pause
-    mock_receipt_proto = TransactionReceiptProto(
-        status=ResponseCode.SUCCESS
-    )
-    
-    # Create a response for the receipt query
-    receipt_query_response = response_pb2.Response(
+    """
+    A properly built & signed TokenPauseTransaction against a mock server
+    should return a SUCCESS receipt.
+    """
+    sender, _, node_account, fungible_token, _ = mock_account_ids
+
+    # 1) Precheck-ok response
+    ok_resp = TransactionResponseProto(nodeTransactionPrecheckCode=ResponseCode.OK)
+    # 2) Receipt SUCCESS response
+    success_receipt = TransactionReceiptProto(status=ResponseCode.SUCCESS)
+    receipt_query = response_pb2.Response(
         transactionGetReceipt=transaction_get_receipt_pb2.TransactionGetReceiptResponse(
             header=response_header_pb2.ResponseHeader(
                 nodeTransactionPrecheckCode=ResponseCode.OK
             ),
-            receipt=mock_receipt_proto
+            receipt=success_receipt
         )
     )
-    
+
     response_sequences = [
-        [ok_response, receipt_query_response],
+        [ok_resp, receipt_query],
     ]
-    
     with mock_hedera_servers(response_sequences) as client:
-        # Build the transaction
-        transaction = (
-            TokenPauseTransaction()
-            .set_token_id(token_id)
-        )
-        # Set identifiers so freeze/sign can populate the payload correctly
-        transaction.transaction_id = generate_transaction_id(account_id)
-        transaction.node_account_id = node_account_id
-
-        # Freeze and sign before execute
-        transaction.freeze_with(client)
-        dummy_key = MagicMock()
-        dummy_key.sign.return_value = b'__SIG__'
-        dummy_key.public_key().to_bytes_raw.return_value = b'PUB'
-        transaction.sign(dummy_key)
+        pause_tx = TokenPauseTransaction().set_token_id(fungible_token)
+        pause_tx.transaction_id  = TransactionId.generate(sender)
+        pause_tx.node_account_id = node_account
+
+        pause_tx.freeze_with(client)
+
+        dummy_priv_key = MagicMock()
+        dummy_priv_key.sign.return_value = b'__SIG__'
 
-        # Execute and assert
-        receipt = transaction.execute(client)
-        assert receipt.status == ResponseCode.SUCCESS, "Transaction should have succeeded"
+        dummy_pub_key = dummy_priv_key.public_key()
+        dummy_pub_key.to_bytes_raw.return_value = b'PUB'
+
+        pause_tx.sign(dummy_priv_key)
+
+        receipt = pause_tx.execute(client)
+        assert receipt.status == ResponseCode.SUCCESS
+
+